/*
Copyright 2016 The Kubernetes Authors.

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/

// ************************************************************
// DO NOT EDIT.
// THIS FILE IS AUTO-GENERATED BY codecgen.
// ************************************************************

package extensions

import (
	"errors"
	"fmt"
	codec1978 "github.com/ugorji/go/codec"
	pkg2_api "k8s.io/kubernetes/pkg/api"
	pkg4_resource "k8s.io/kubernetes/pkg/api/resource"
	pkg1_unversioned "k8s.io/kubernetes/pkg/api/unversioned"
	pkg3_types "k8s.io/kubernetes/pkg/types"
	pkg5_intstr "k8s.io/kubernetes/pkg/util/intstr"
	"reflect"
	"runtime"
	time "time"
)

const (
	// ----- content types ----
	codecSelferC_UTF81234 = 1
	codecSelferC_RAW1234  = 0
	// ----- value types used ----
	codecSelferValueTypeArray1234 = 10
	codecSelferValueTypeMap1234   = 9
	// ----- containerStateValues ----
	codecSelfer_containerMapKey1234    = 2
	codecSelfer_containerMapValue1234  = 3
	codecSelfer_containerMapEnd1234    = 4
	codecSelfer_containerArrayElem1234 = 6
	codecSelfer_containerArrayEnd1234  = 7
)

var (
	codecSelferBitsize1234                         = uint8(reflect.TypeOf(uint(0)).Bits())
	codecSelferOnlyMapOrArrayEncodeToStructErr1234 = errors.New(`only encoded map or array can be decoded into a struct`)
)

type codecSelfer1234 struct{}

func init() {
	if codec1978.GenVersion != 5 {
		_, file, _, _ := runtime.Caller(0)
		err := fmt.Errorf("codecgen version mismatch: current: %v, need %v. Re-generate file: %v",
			5, codec1978.GenVersion, file)
		panic(err)
	}
	if false { // reference the types, but skip this branch at build/run time
		var v0 pkg2_api.ObjectMeta
		var v1 pkg4_resource.Quantity
		var v2 pkg1_unversioned.LabelSelector
		var v3 pkg3_types.UID
		var v4 pkg5_intstr.IntOrString
		var v5 time.Time
		_, _, _, _, _, _ = v0, v1, v2, v3, v4, v5
	}
}

func (x *ScaleSpec) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym1 := z.EncBinary()
		_ = yym1
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep2 := !z.EncBinary()
			yy2arr2 := z.EncBasicHandle().StructToArray
			var yyq2 [1]bool
			_, _, _ = yysep2, yyq2, yy2arr2
			const yyr2 bool = false
			yyq2[0] = x.Replicas != 0
			var yynn2 int
			if yyr2 || yy2arr2 {
				r.EncodeArrayStart(1)
			} else {
				yynn2 = 0
				for _, b := range yyq2 {
					if b {
						yynn2++
					}
				}
				r.EncodeMapStart(yynn2)
				yynn2 = 0
			}
			if yyr2 || yy2arr2 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq2[0] {
					yym4 := z.EncBinary()
					_ = yym4
					if false {
					} else {
						r.EncodeInt(int64(x.Replicas))
					}
				} else {
					r.EncodeInt(0)
				}
			} else {
				if yyq2[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("replicas"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym5 := z.EncBinary()
					_ = yym5
					if false {
					} else {
						r.EncodeInt(int64(x.Replicas))
					}
				}
			}
			if yyr2 || yy2arr2 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *ScaleSpec) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym6 := z.DecBinary()
	_ = yym6
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct7 := r.ContainerType()
		if yyct7 == codecSelferValueTypeMap1234 {
			yyl7 := r.ReadMapStart()
			if yyl7 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl7, d)
			}
		} else if yyct7 == codecSelferValueTypeArray1234 {
			yyl7 := r.ReadArrayStart()
			if yyl7 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl7, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *ScaleSpec) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys8Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys8Slc
	var yyhl8 bool = l >= 0
	for yyj8 := 0; ; yyj8++ {
		if yyhl8 {
			if yyj8 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys8Slc = r.DecodeBytes(yys8Slc, true, true)
		yys8 := string(yys8Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys8 {
		case "replicas":
			if r.TryDecodeAsNil() {
				x.Replicas = 0
			} else {
				x.Replicas = int32(r.DecodeInt(32))
			}
		default:
			z.DecStructFieldNotFound(-1, yys8)
		} // end switch yys8
	} // end for yyj8
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *ScaleSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj10 int
	var yyb10 bool
	var yyhl10 bool = l >= 0
	yyj10++
	if yyhl10 {
		yyb10 = yyj10 > l
	} else {
		yyb10 = r.CheckBreak()
	}
	if yyb10 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Replicas = 0
	} else {
		x.Replicas = int32(r.DecodeInt(32))
	}
	for {
		yyj10++
		if yyhl10 {
			yyb10 = yyj10 > l
		} else {
			yyb10 = r.CheckBreak()
		}
		if yyb10 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj10-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *ScaleStatus) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym12 := z.EncBinary()
		_ = yym12
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep13 := !z.EncBinary()
			yy2arr13 := z.EncBasicHandle().StructToArray
			var yyq13 [2]bool
			_, _, _ = yysep13, yyq13, yy2arr13
			const yyr13 bool = false
			yyq13[1] = x.Selector != nil
			var yynn13 int
			if yyr13 || yy2arr13 {
				r.EncodeArrayStart(2)
			} else {
				yynn13 = 1
				for _, b := range yyq13 {
					if b {
						yynn13++
					}
				}
				r.EncodeMapStart(yynn13)
				yynn13 = 0
			}
			if yyr13 || yy2arr13 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym15 := z.EncBinary()
				_ = yym15
				if false {
				} else {
					r.EncodeInt(int64(x.Replicas))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("replicas"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yym16 := z.EncBinary()
				_ = yym16
				if false {
				} else {
					r.EncodeInt(int64(x.Replicas))
				}
			}
			if yyr13 || yy2arr13 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq13[1] {
					if x.Selector == nil {
						r.EncodeNil()
					} else {
						yym18 := z.EncBinary()
						_ = yym18
						if false {
						} else if z.HasExtensions() && z.EncExt(x.Selector) {
						} else {
							z.EncFallback(x.Selector)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq13[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("selector"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.Selector == nil {
						r.EncodeNil()
					} else {
						yym19 := z.EncBinary()
						_ = yym19
						if false {
						} else if z.HasExtensions() && z.EncExt(x.Selector) {
						} else {
							z.EncFallback(x.Selector)
						}
					}
				}
			}
			if yyr13 || yy2arr13 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *ScaleStatus) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym20 := z.DecBinary()
	_ = yym20
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct21 := r.ContainerType()
		if yyct21 == codecSelferValueTypeMap1234 {
			yyl21 := r.ReadMapStart()
			if yyl21 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl21, d)
			}
		} else if yyct21 == codecSelferValueTypeArray1234 {
			yyl21 := r.ReadArrayStart()
			if yyl21 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl21, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *ScaleStatus) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys22Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys22Slc
	var yyhl22 bool = l >= 0
	for yyj22 := 0; ; yyj22++ {
		if yyhl22 {
			if yyj22 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys22Slc = r.DecodeBytes(yys22Slc, true, true)
		yys22 := string(yys22Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys22 {
		case "replicas":
			if r.TryDecodeAsNil() {
				x.Replicas = 0
			} else {
				x.Replicas = int32(r.DecodeInt(32))
			}
		case "selector":
			if r.TryDecodeAsNil() {
				if x.Selector != nil {
					x.Selector = nil
				}
			} else {
				if x.Selector == nil {
					x.Selector = new(pkg1_unversioned.LabelSelector)
				}
				yym25 := z.DecBinary()
				_ = yym25
				if false {
				} else if z.HasExtensions() && z.DecExt(x.Selector) {
				} else {
					z.DecFallback(x.Selector, false)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys22)
		} // end switch yys22
	} // end for yyj22
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *ScaleStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj26 int
	var yyb26 bool
	var yyhl26 bool = l >= 0
	yyj26++
	if yyhl26 {
		yyb26 = yyj26 > l
	} else {
		yyb26 = r.CheckBreak()
	}
	if yyb26 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Replicas = 0
	} else {
		x.Replicas = int32(r.DecodeInt(32))
	}
	yyj26++
	if yyhl26 {
		yyb26 = yyj26 > l
	} else {
		yyb26 = r.CheckBreak()
	}
	if yyb26 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		if x.Selector != nil {
			x.Selector = nil
		}
	} else {
		if x.Selector == nil {
			x.Selector = new(pkg1_unversioned.LabelSelector)
		}
		yym29 := z.DecBinary()
		_ = yym29
		if false {
		} else if z.HasExtensions() && z.DecExt(x.Selector) {
		} else {
			z.DecFallback(x.Selector, false)
		}
	}
	for {
		yyj26++
		if yyhl26 {
			yyb26 = yyj26 > l
		} else {
			yyb26 = r.CheckBreak()
		}
		if yyb26 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj26-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *Scale) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym30 := z.EncBinary()
		_ = yym30
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep31 := !z.EncBinary()
			yy2arr31 := z.EncBasicHandle().StructToArray
			var yyq31 [5]bool
			_, _, _ = yysep31, yyq31, yy2arr31
			const yyr31 bool = false
			yyq31[0] = x.Kind != ""
			yyq31[1] = x.APIVersion != ""
			yyq31[2] = true
			yyq31[3] = true
			yyq31[4] = true
			var yynn31 int
			if yyr31 || yy2arr31 {
				r.EncodeArrayStart(5)
			} else {
				yynn31 = 0
				for _, b := range yyq31 {
					if b {
						yynn31++
					}
				}
				r.EncodeMapStart(yynn31)
				yynn31 = 0
			}
			if yyr31 || yy2arr31 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq31[0] {
					yym33 := z.EncBinary()
					_ = yym33
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq31[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym34 := z.EncBinary()
					_ = yym34
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr31 || yy2arr31 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq31[1] {
					yym36 := z.EncBinary()
					_ = yym36
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq31[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym37 := z.EncBinary()
					_ = yym37
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr31 || yy2arr31 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq31[2] {
					yy39 := &x.ObjectMeta
					yy39.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq31[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy40 := &x.ObjectMeta
					yy40.CodecEncodeSelf(e)
				}
			}
			if yyr31 || yy2arr31 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq31[3] {
					yy42 := &x.Spec
					yy42.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq31[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("spec"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy43 := &x.Spec
					yy43.CodecEncodeSelf(e)
				}
			}
			if yyr31 || yy2arr31 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq31[4] {
					yy45 := &x.Status
					yy45.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq31[4] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("status"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy46 := &x.Status
					yy46.CodecEncodeSelf(e)
				}
			}
			if yyr31 || yy2arr31 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *Scale) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym47 := z.DecBinary()
	_ = yym47
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct48 := r.ContainerType()
		if yyct48 == codecSelferValueTypeMap1234 {
			yyl48 := r.ReadMapStart()
			if yyl48 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl48, d)
			}
		} else if yyct48 == codecSelferValueTypeArray1234 {
			yyl48 := r.ReadArrayStart()
			if yyl48 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl48, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *Scale) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys49Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys49Slc
	var yyhl49 bool = l >= 0
	for yyj49 := 0; ; yyj49++ {
		if yyhl49 {
			if yyj49 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys49Slc = r.DecodeBytes(yys49Slc, true, true)
		yys49 := string(yys49Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys49 {
		case "kind":
			if r.TryDecodeAsNil() {
				x.Kind = ""
			} else {
				x.Kind = string(r.DecodeString())
			}
		case "apiVersion":
			if r.TryDecodeAsNil() {
				x.APIVersion = ""
			} else {
				x.APIVersion = string(r.DecodeString())
			}
		case "metadata":
			if r.TryDecodeAsNil() {
				x.ObjectMeta = pkg2_api.ObjectMeta{}
			} else {
				yyv52 := &x.ObjectMeta
				yyv52.CodecDecodeSelf(d)
			}
		case "spec":
			if r.TryDecodeAsNil() {
				x.Spec = ScaleSpec{}
			} else {
				yyv53 := &x.Spec
				yyv53.CodecDecodeSelf(d)
			}
		case "status":
			if r.TryDecodeAsNil() {
				x.Status = ScaleStatus{}
			} else {
				yyv54 := &x.Status
				yyv54.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys49)
		} // end switch yys49
	} // end for yyj49
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *Scale) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj55 int
	var yyb55 bool
	var yyhl55 bool = l >= 0
	yyj55++
	if yyhl55 {
		yyb55 = yyj55 > l
	} else {
		yyb55 = r.CheckBreak()
	}
	if yyb55 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj55++
	if yyhl55 {
		yyb55 = yyj55 > l
	} else {
		yyb55 = r.CheckBreak()
	}
	if yyb55 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj55++
	if yyhl55 {
		yyb55 = yyj55 > l
	} else {
		yyb55 = r.CheckBreak()
	}
	if yyb55 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ObjectMeta = pkg2_api.ObjectMeta{}
	} else {
		yyv58 := &x.ObjectMeta
		yyv58.CodecDecodeSelf(d)
	}
	yyj55++
	if yyhl55 {
		yyb55 = yyj55 > l
	} else {
		yyb55 = r.CheckBreak()
	}
	if yyb55 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Spec = ScaleSpec{}
	} else {
		yyv59 := &x.Spec
		yyv59.CodecDecodeSelf(d)
	}
	yyj55++
	if yyhl55 {
		yyb55 = yyj55 > l
	} else {
		yyb55 = r.CheckBreak()
	}
	if yyb55 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Status = ScaleStatus{}
	} else {
		yyv60 := &x.Status
		yyv60.CodecDecodeSelf(d)
	}
	for {
		yyj55++
		if yyhl55 {
			yyb55 = yyj55 > l
		} else {
			yyb55 = r.CheckBreak()
		}
		if yyb55 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj55-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *ReplicationControllerDummy) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym61 := z.EncBinary()
		_ = yym61
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep62 := !z.EncBinary()
			yy2arr62 := z.EncBasicHandle().StructToArray
			var yyq62 [2]bool
			_, _, _ = yysep62, yyq62, yy2arr62
			const yyr62 bool = false
			yyq62[0] = x.Kind != ""
			yyq62[1] = x.APIVersion != ""
			var yynn62 int
			if yyr62 || yy2arr62 {
				r.EncodeArrayStart(2)
			} else {
				yynn62 = 0
				for _, b := range yyq62 {
					if b {
						yynn62++
					}
				}
				r.EncodeMapStart(yynn62)
				yynn62 = 0
			}
			if yyr62 || yy2arr62 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq62[0] {
					yym64 := z.EncBinary()
					_ = yym64
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq62[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym65 := z.EncBinary()
					_ = yym65
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr62 || yy2arr62 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq62[1] {
					yym67 := z.EncBinary()
					_ = yym67
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq62[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym68 := z.EncBinary()
					_ = yym68
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr62 || yy2arr62 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *ReplicationControllerDummy) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym69 := z.DecBinary()
	_ = yym69
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct70 := r.ContainerType()
		if yyct70 == codecSelferValueTypeMap1234 {
			yyl70 := r.ReadMapStart()
			if yyl70 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl70, d)
			}
		} else if yyct70 == codecSelferValueTypeArray1234 {
			yyl70 := r.ReadArrayStart()
			if yyl70 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl70, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *ReplicationControllerDummy) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys71Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys71Slc
	var yyhl71 bool = l >= 0
	for yyj71 := 0; ; yyj71++ {
		if yyhl71 {
			if yyj71 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys71Slc = r.DecodeBytes(yys71Slc, true, true)
		yys71 := string(yys71Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys71 {
		case "kind":
			if r.TryDecodeAsNil() {
				x.Kind = ""
			} else {
				x.Kind = string(r.DecodeString())
			}
		case "apiVersion":
			if r.TryDecodeAsNil() {
				x.APIVersion = ""
			} else {
				x.APIVersion = string(r.DecodeString())
			}
		default:
			z.DecStructFieldNotFound(-1, yys71)
		} // end switch yys71
	} // end for yyj71
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *ReplicationControllerDummy) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj74 int
	var yyb74 bool
	var yyhl74 bool = l >= 0
	yyj74++
	if yyhl74 {
		yyb74 = yyj74 > l
	} else {
		yyb74 = r.CheckBreak()
	}
	if yyb74 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj74++
	if yyhl74 {
		yyb74 = yyj74 > l
	} else {
		yyb74 = r.CheckBreak()
	}
	if yyb74 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	for {
		yyj74++
		if yyhl74 {
			yyb74 = yyj74 > l
		} else {
			yyb74 = r.CheckBreak()
		}
		if yyb74 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj74-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *CustomMetricTarget) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym77 := z.EncBinary()
		_ = yym77
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep78 := !z.EncBinary()
			yy2arr78 := z.EncBasicHandle().StructToArray
			var yyq78 [2]bool
			_, _, _ = yysep78, yyq78, yy2arr78
			const yyr78 bool = false
			var yynn78 int
			if yyr78 || yy2arr78 {
				r.EncodeArrayStart(2)
			} else {
				yynn78 = 2
				for _, b := range yyq78 {
					if b {
						yynn78++
					}
				}
				r.EncodeMapStart(yynn78)
				yynn78 = 0
			}
			if yyr78 || yy2arr78 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym80 := z.EncBinary()
				_ = yym80
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF81234, string(x.Name))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("name"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yym81 := z.EncBinary()
				_ = yym81
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF81234, string(x.Name))
				}
			}
			if yyr78 || yy2arr78 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yy83 := &x.TargetValue
				yym84 := z.EncBinary()
				_ = yym84
				if false {
				} else if z.HasExtensions() && z.EncExt(yy83) {
				} else if !yym84 && z.IsJSONHandle() {
					z.EncJSONMarshal(yy83)
				} else {
					z.EncFallback(yy83)
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("value"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yy85 := &x.TargetValue
				yym86 := z.EncBinary()
				_ = yym86
				if false {
				} else if z.HasExtensions() && z.EncExt(yy85) {
				} else if !yym86 && z.IsJSONHandle() {
					z.EncJSONMarshal(yy85)
				} else {
					z.EncFallback(yy85)
				}
			}
			if yyr78 || yy2arr78 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *CustomMetricTarget) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym87 := z.DecBinary()
	_ = yym87
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct88 := r.ContainerType()
		if yyct88 == codecSelferValueTypeMap1234 {
			yyl88 := r.ReadMapStart()
			if yyl88 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl88, d)
			}
		} else if yyct88 == codecSelferValueTypeArray1234 {
			yyl88 := r.ReadArrayStart()
			if yyl88 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl88, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *CustomMetricTarget) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys89Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys89Slc
	var yyhl89 bool = l >= 0
	for yyj89 := 0; ; yyj89++ {
		if yyhl89 {
			if yyj89 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys89Slc = r.DecodeBytes(yys89Slc, true, true)
		yys89 := string(yys89Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys89 {
		case "name":
			if r.TryDecodeAsNil() {
				x.Name = ""
			} else {
				x.Name = string(r.DecodeString())
			}
		case "value":
			if r.TryDecodeAsNil() {
				x.TargetValue = pkg4_resource.Quantity{}
			} else {
				yyv91 := &x.TargetValue
				yym92 := z.DecBinary()
				_ = yym92
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv91) {
				} else if !yym92 && z.IsJSONHandle() {
					z.DecJSONUnmarshal(yyv91)
				} else {
					z.DecFallback(yyv91, false)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys89)
		} // end switch yys89
	} // end for yyj89
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *CustomMetricTarget) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj93 int
	var yyb93 bool
	var yyhl93 bool = l >= 0
	yyj93++
	if yyhl93 {
		yyb93 = yyj93 > l
	} else {
		yyb93 = r.CheckBreak()
	}
	if yyb93 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Name = ""
	} else {
		x.Name = string(r.DecodeString())
	}
	yyj93++
	if yyhl93 {
		yyb93 = yyj93 > l
	} else {
		yyb93 = r.CheckBreak()
	}
	if yyb93 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.TargetValue = pkg4_resource.Quantity{}
	} else {
		yyv95 := &x.TargetValue
		yym96 := z.DecBinary()
		_ = yym96
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv95) {
		} else if !yym96 && z.IsJSONHandle() {
			z.DecJSONUnmarshal(yyv95)
		} else {
			z.DecFallback(yyv95, false)
		}
	}
	for {
		yyj93++
		if yyhl93 {
			yyb93 = yyj93 > l
		} else {
			yyb93 = r.CheckBreak()
		}
		if yyb93 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj93-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *CustomMetricTargetList) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym97 := z.EncBinary()
		_ = yym97
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep98 := !z.EncBinary()
			yy2arr98 := z.EncBasicHandle().StructToArray
			var yyq98 [1]bool
			_, _, _ = yysep98, yyq98, yy2arr98
			const yyr98 bool = false
			var yynn98 int
			if yyr98 || yy2arr98 {
				r.EncodeArrayStart(1)
			} else {
				yynn98 = 1
				for _, b := range yyq98 {
					if b {
						yynn98++
					}
				}
				r.EncodeMapStart(yynn98)
				yynn98 = 0
			}
			if yyr98 || yy2arr98 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym100 := z.EncBinary()
					_ = yym100
					if false {
					} else {
						h.encSliceCustomMetricTarget(([]CustomMetricTarget)(x.Items), e)
					}
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("items"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym101 := z.EncBinary()
					_ = yym101
					if false {
					} else {
						h.encSliceCustomMetricTarget(([]CustomMetricTarget)(x.Items), e)
					}
				}
			}
			if yyr98 || yy2arr98 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *CustomMetricTargetList) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym102 := z.DecBinary()
	_ = yym102
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct103 := r.ContainerType()
		if yyct103 == codecSelferValueTypeMap1234 {
			yyl103 := r.ReadMapStart()
			if yyl103 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl103, d)
			}
		} else if yyct103 == codecSelferValueTypeArray1234 {
			yyl103 := r.ReadArrayStart()
			if yyl103 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl103, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *CustomMetricTargetList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys104Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys104Slc
	var yyhl104 bool = l >= 0
	for yyj104 := 0; ; yyj104++ {
		if yyhl104 {
			if yyj104 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys104Slc = r.DecodeBytes(yys104Slc, true, true)
		yys104 := string(yys104Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys104 {
		case "items":
			if r.TryDecodeAsNil() {
				x.Items = nil
			} else {
				yyv105 := &x.Items
				yym106 := z.DecBinary()
				_ = yym106
				if false {
				} else {
					h.decSliceCustomMetricTarget((*[]CustomMetricTarget)(yyv105), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys104)
		} // end switch yys104
	} // end for yyj104
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *CustomMetricTargetList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj107 int
	var yyb107 bool
	var yyhl107 bool = l >= 0
	yyj107++
	if yyhl107 {
		yyb107 = yyj107 > l
	} else {
		yyb107 = r.CheckBreak()
	}
	if yyb107 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Items = nil
	} else {
		yyv108 := &x.Items
		yym109 := z.DecBinary()
		_ = yym109
		if false {
		} else {
			h.decSliceCustomMetricTarget((*[]CustomMetricTarget)(yyv108), d)
		}
	}
	for {
		yyj107++
		if yyhl107 {
			yyb107 = yyj107 > l
		} else {
			yyb107 = r.CheckBreak()
		}
		if yyb107 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj107-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *CustomMetricCurrentStatus) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym110 := z.EncBinary()
		_ = yym110
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep111 := !z.EncBinary()
			yy2arr111 := z.EncBasicHandle().StructToArray
			var yyq111 [2]bool
			_, _, _ = yysep111, yyq111, yy2arr111
			const yyr111 bool = false
			var yynn111 int
			if yyr111 || yy2arr111 {
				r.EncodeArrayStart(2)
			} else {
				yynn111 = 2
				for _, b := range yyq111 {
					if b {
						yynn111++
					}
				}
				r.EncodeMapStart(yynn111)
				yynn111 = 0
			}
			if yyr111 || yy2arr111 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym113 := z.EncBinary()
				_ = yym113
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF81234, string(x.Name))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("name"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yym114 := z.EncBinary()
				_ = yym114
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF81234, string(x.Name))
				}
			}
			if yyr111 || yy2arr111 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yy116 := &x.CurrentValue
				yym117 := z.EncBinary()
				_ = yym117
				if false {
				} else if z.HasExtensions() && z.EncExt(yy116) {
				} else if !yym117 && z.IsJSONHandle() {
					z.EncJSONMarshal(yy116)
				} else {
					z.EncFallback(yy116)
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("value"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yy118 := &x.CurrentValue
				yym119 := z.EncBinary()
				_ = yym119
				if false {
				} else if z.HasExtensions() && z.EncExt(yy118) {
				} else if !yym119 && z.IsJSONHandle() {
					z.EncJSONMarshal(yy118)
				} else {
					z.EncFallback(yy118)
				}
			}
			if yyr111 || yy2arr111 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *CustomMetricCurrentStatus) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym120 := z.DecBinary()
	_ = yym120
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct121 := r.ContainerType()
		if yyct121 == codecSelferValueTypeMap1234 {
			yyl121 := r.ReadMapStart()
			if yyl121 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl121, d)
			}
		} else if yyct121 == codecSelferValueTypeArray1234 {
			yyl121 := r.ReadArrayStart()
			if yyl121 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl121, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *CustomMetricCurrentStatus) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys122Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys122Slc
	var yyhl122 bool = l >= 0
	for yyj122 := 0; ; yyj122++ {
		if yyhl122 {
			if yyj122 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys122Slc = r.DecodeBytes(yys122Slc, true, true)
		yys122 := string(yys122Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys122 {
		case "name":
			if r.TryDecodeAsNil() {
				x.Name = ""
			} else {
				x.Name = string(r.DecodeString())
			}
		case "value":
			if r.TryDecodeAsNil() {
				x.CurrentValue = pkg4_resource.Quantity{}
			} else {
				yyv124 := &x.CurrentValue
				yym125 := z.DecBinary()
				_ = yym125
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv124) {
				} else if !yym125 && z.IsJSONHandle() {
					z.DecJSONUnmarshal(yyv124)
				} else {
					z.DecFallback(yyv124, false)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys122)
		} // end switch yys122
	} // end for yyj122
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *CustomMetricCurrentStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj126 int
	var yyb126 bool
	var yyhl126 bool = l >= 0
	yyj126++
	if yyhl126 {
		yyb126 = yyj126 > l
	} else {
		yyb126 = r.CheckBreak()
	}
	if yyb126 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Name = ""
	} else {
		x.Name = string(r.DecodeString())
	}
	yyj126++
	if yyhl126 {
		yyb126 = yyj126 > l
	} else {
		yyb126 = r.CheckBreak()
	}
	if yyb126 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.CurrentValue = pkg4_resource.Quantity{}
	} else {
		yyv128 := &x.CurrentValue
		yym129 := z.DecBinary()
		_ = yym129
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv128) {
		} else if !yym129 && z.IsJSONHandle() {
			z.DecJSONUnmarshal(yyv128)
		} else {
			z.DecFallback(yyv128, false)
		}
	}
	for {
		yyj126++
		if yyhl126 {
			yyb126 = yyj126 > l
		} else {
			yyb126 = r.CheckBreak()
		}
		if yyb126 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj126-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *CustomMetricCurrentStatusList) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym130 := z.EncBinary()
		_ = yym130
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep131 := !z.EncBinary()
			yy2arr131 := z.EncBasicHandle().StructToArray
			var yyq131 [1]bool
			_, _, _ = yysep131, yyq131, yy2arr131
			const yyr131 bool = false
			var yynn131 int
			if yyr131 || yy2arr131 {
				r.EncodeArrayStart(1)
			} else {
				yynn131 = 1
				for _, b := range yyq131 {
					if b {
						yynn131++
					}
				}
				r.EncodeMapStart(yynn131)
				yynn131 = 0
			}
			if yyr131 || yy2arr131 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym133 := z.EncBinary()
					_ = yym133
					if false {
					} else {
						h.encSliceCustomMetricCurrentStatus(([]CustomMetricCurrentStatus)(x.Items), e)
					}
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("items"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym134 := z.EncBinary()
					_ = yym134
					if false {
					} else {
						h.encSliceCustomMetricCurrentStatus(([]CustomMetricCurrentStatus)(x.Items), e)
					}
				}
			}
			if yyr131 || yy2arr131 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *CustomMetricCurrentStatusList) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym135 := z.DecBinary()
	_ = yym135
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct136 := r.ContainerType()
		if yyct136 == codecSelferValueTypeMap1234 {
			yyl136 := r.ReadMapStart()
			if yyl136 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl136, d)
			}
		} else if yyct136 == codecSelferValueTypeArray1234 {
			yyl136 := r.ReadArrayStart()
			if yyl136 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl136, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *CustomMetricCurrentStatusList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys137Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys137Slc
	var yyhl137 bool = l >= 0
	for yyj137 := 0; ; yyj137++ {
		if yyhl137 {
			if yyj137 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys137Slc = r.DecodeBytes(yys137Slc, true, true)
		yys137 := string(yys137Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys137 {
		case "items":
			if r.TryDecodeAsNil() {
				x.Items = nil
			} else {
				yyv138 := &x.Items
				yym139 := z.DecBinary()
				_ = yym139
				if false {
				} else {
					h.decSliceCustomMetricCurrentStatus((*[]CustomMetricCurrentStatus)(yyv138), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys137)
		} // end switch yys137
	} // end for yyj137
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *CustomMetricCurrentStatusList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj140 int
	var yyb140 bool
	var yyhl140 bool = l >= 0
	yyj140++
	if yyhl140 {
		yyb140 = yyj140 > l
	} else {
		yyb140 = r.CheckBreak()
	}
	if yyb140 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Items = nil
	} else {
		yyv141 := &x.Items
		yym142 := z.DecBinary()
		_ = yym142
		if false {
		} else {
			h.decSliceCustomMetricCurrentStatus((*[]CustomMetricCurrentStatus)(yyv141), d)
		}
	}
	for {
		yyj140++
		if yyhl140 {
			yyb140 = yyj140 > l
		} else {
			yyb140 = r.CheckBreak()
		}
		if yyb140 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj140-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *ThirdPartyResource) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym143 := z.EncBinary()
		_ = yym143
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep144 := !z.EncBinary()
			yy2arr144 := z.EncBasicHandle().StructToArray
			var yyq144 [5]bool
			_, _, _ = yysep144, yyq144, yy2arr144
			const yyr144 bool = false
			yyq144[0] = x.Kind != ""
			yyq144[1] = x.APIVersion != ""
			yyq144[2] = true
			yyq144[3] = x.Description != ""
			yyq144[4] = len(x.Versions) != 0
			var yynn144 int
			if yyr144 || yy2arr144 {
				r.EncodeArrayStart(5)
			} else {
				yynn144 = 0
				for _, b := range yyq144 {
					if b {
						yynn144++
					}
				}
				r.EncodeMapStart(yynn144)
				yynn144 = 0
			}
			if yyr144 || yy2arr144 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq144[0] {
					yym146 := z.EncBinary()
					_ = yym146
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq144[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym147 := z.EncBinary()
					_ = yym147
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr144 || yy2arr144 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq144[1] {
					yym149 := z.EncBinary()
					_ = yym149
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq144[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym150 := z.EncBinary()
					_ = yym150
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr144 || yy2arr144 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq144[2] {
					yy152 := &x.ObjectMeta
					yy152.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq144[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy153 := &x.ObjectMeta
					yy153.CodecEncodeSelf(e)
				}
			}
			if yyr144 || yy2arr144 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq144[3] {
					yym155 := z.EncBinary()
					_ = yym155
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Description))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq144[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("description"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym156 := z.EncBinary()
					_ = yym156
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Description))
					}
				}
			}
			if yyr144 || yy2arr144 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq144[4] {
					if x.Versions == nil {
						r.EncodeNil()
					} else {
						yym158 := z.EncBinary()
						_ = yym158
						if false {
						} else {
							h.encSliceAPIVersion(([]APIVersion)(x.Versions), e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq144[4] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("versions"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.Versions == nil {
						r.EncodeNil()
					} else {
						yym159 := z.EncBinary()
						_ = yym159
						if false {
						} else {
							h.encSliceAPIVersion(([]APIVersion)(x.Versions), e)
						}
					}
				}
			}
			if yyr144 || yy2arr144 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *ThirdPartyResource) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym160 := z.DecBinary()
	_ = yym160
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct161 := r.ContainerType()
		if yyct161 == codecSelferValueTypeMap1234 {
			yyl161 := r.ReadMapStart()
			if yyl161 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl161, d)
			}
		} else if yyct161 == codecSelferValueTypeArray1234 {
			yyl161 := r.ReadArrayStart()
			if yyl161 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl161, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *ThirdPartyResource) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys162Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys162Slc
	var yyhl162 bool = l >= 0
	for yyj162 := 0; ; yyj162++ {
		if yyhl162 {
			if yyj162 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys162Slc = r.DecodeBytes(yys162Slc, true, true)
		yys162 := string(yys162Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys162 {
		case "kind":
			if r.TryDecodeAsNil() {
				x.Kind = ""
			} else {
				x.Kind = string(r.DecodeString())
			}
		case "apiVersion":
			if r.TryDecodeAsNil() {
				x.APIVersion = ""
			} else {
				x.APIVersion = string(r.DecodeString())
			}
		case "metadata":
			if r.TryDecodeAsNil() {
				x.ObjectMeta = pkg2_api.ObjectMeta{}
			} else {
				yyv165 := &x.ObjectMeta
				yyv165.CodecDecodeSelf(d)
			}
		case "description":
			if r.TryDecodeAsNil() {
				x.Description = ""
			} else {
				x.Description = string(r.DecodeString())
			}
		case "versions":
			if r.TryDecodeAsNil() {
				x.Versions = nil
			} else {
				yyv167 := &x.Versions
				yym168 := z.DecBinary()
				_ = yym168
				if false {
				} else {
					h.decSliceAPIVersion((*[]APIVersion)(yyv167), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys162)
		} // end switch yys162
	} // end for yyj162
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *ThirdPartyResource) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj169 int
	var yyb169 bool
	var yyhl169 bool = l >= 0
	yyj169++
	if yyhl169 {
		yyb169 = yyj169 > l
	} else {
		yyb169 = r.CheckBreak()
	}
	if yyb169 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj169++
	if yyhl169 {
		yyb169 = yyj169 > l
	} else {
		yyb169 = r.CheckBreak()
	}
	if yyb169 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj169++
	if yyhl169 {
		yyb169 = yyj169 > l
	} else {
		yyb169 = r.CheckBreak()
	}
	if yyb169 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ObjectMeta = pkg2_api.ObjectMeta{}
	} else {
		yyv172 := &x.ObjectMeta
		yyv172.CodecDecodeSelf(d)
	}
	yyj169++
	if yyhl169 {
		yyb169 = yyj169 > l
	} else {
		yyb169 = r.CheckBreak()
	}
	if yyb169 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Description = ""
	} else {
		x.Description = string(r.DecodeString())
	}
	yyj169++
	if yyhl169 {
		yyb169 = yyj169 > l
	} else {
		yyb169 = r.CheckBreak()
	}
	if yyb169 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Versions = nil
	} else {
		yyv174 := &x.Versions
		yym175 := z.DecBinary()
		_ = yym175
		if false {
		} else {
			h.decSliceAPIVersion((*[]APIVersion)(yyv174), d)
		}
	}
	for {
		yyj169++
		if yyhl169 {
			yyb169 = yyj169 > l
		} else {
			yyb169 = r.CheckBreak()
		}
		if yyb169 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj169-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *ThirdPartyResourceList) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym176 := z.EncBinary()
		_ = yym176
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep177 := !z.EncBinary()
			yy2arr177 := z.EncBasicHandle().StructToArray
			var yyq177 [4]bool
			_, _, _ = yysep177, yyq177, yy2arr177
			const yyr177 bool = false
			yyq177[0] = x.Kind != ""
			yyq177[1] = x.APIVersion != ""
			yyq177[2] = true
			var yynn177 int
			if yyr177 || yy2arr177 {
				r.EncodeArrayStart(4)
			} else {
				yynn177 = 1
				for _, b := range yyq177 {
					if b {
						yynn177++
					}
				}
				r.EncodeMapStart(yynn177)
				yynn177 = 0
			}
			if yyr177 || yy2arr177 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq177[0] {
					yym179 := z.EncBinary()
					_ = yym179
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq177[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym180 := z.EncBinary()
					_ = yym180
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr177 || yy2arr177 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq177[1] {
					yym182 := z.EncBinary()
					_ = yym182
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq177[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym183 := z.EncBinary()
					_ = yym183
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr177 || yy2arr177 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq177[2] {
					yy185 := &x.ListMeta
					yym186 := z.EncBinary()
					_ = yym186
					if false {
					} else if z.HasExtensions() && z.EncExt(yy185) {
					} else {
						z.EncFallback(yy185)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq177[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy187 := &x.ListMeta
					yym188 := z.EncBinary()
					_ = yym188
					if false {
					} else if z.HasExtensions() && z.EncExt(yy187) {
					} else {
						z.EncFallback(yy187)
					}
				}
			}
			if yyr177 || yy2arr177 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym190 := z.EncBinary()
					_ = yym190
					if false {
					} else {
						h.encSliceThirdPartyResource(([]ThirdPartyResource)(x.Items), e)
					}
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("items"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym191 := z.EncBinary()
					_ = yym191
					if false {
					} else {
						h.encSliceThirdPartyResource(([]ThirdPartyResource)(x.Items), e)
					}
				}
			}
			if yyr177 || yy2arr177 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *ThirdPartyResourceList) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym192 := z.DecBinary()
	_ = yym192
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct193 := r.ContainerType()
		if yyct193 == codecSelferValueTypeMap1234 {
			yyl193 := r.ReadMapStart()
			if yyl193 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl193, d)
			}
		} else if yyct193 == codecSelferValueTypeArray1234 {
			yyl193 := r.ReadArrayStart()
			if yyl193 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl193, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *ThirdPartyResourceList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys194Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys194Slc
	var yyhl194 bool = l >= 0
	for yyj194 := 0; ; yyj194++ {
		if yyhl194 {
			if yyj194 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys194Slc = r.DecodeBytes(yys194Slc, true, true)
		yys194 := string(yys194Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys194 {
		case "kind":
			if r.TryDecodeAsNil() {
				x.Kind = ""
			} else {
				x.Kind = string(r.DecodeString())
			}
		case "apiVersion":
			if r.TryDecodeAsNil() {
				x.APIVersion = ""
			} else {
				x.APIVersion = string(r.DecodeString())
			}
		case "metadata":
			if r.TryDecodeAsNil() {
				x.ListMeta = pkg1_unversioned.ListMeta{}
			} else {
				yyv197 := &x.ListMeta
				yym198 := z.DecBinary()
				_ = yym198
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv197) {
				} else {
					z.DecFallback(yyv197, false)
				}
			}
		case "items":
			if r.TryDecodeAsNil() {
				x.Items = nil
			} else {
				yyv199 := &x.Items
				yym200 := z.DecBinary()
				_ = yym200
				if false {
				} else {
					h.decSliceThirdPartyResource((*[]ThirdPartyResource)(yyv199), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys194)
		} // end switch yys194
	} // end for yyj194
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *ThirdPartyResourceList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj201 int
	var yyb201 bool
	var yyhl201 bool = l >= 0
	yyj201++
	if yyhl201 {
		yyb201 = yyj201 > l
	} else {
		yyb201 = r.CheckBreak()
	}
	if yyb201 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj201++
	if yyhl201 {
		yyb201 = yyj201 > l
	} else {
		yyb201 = r.CheckBreak()
	}
	if yyb201 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj201++
	if yyhl201 {
		yyb201 = yyj201 > l
	} else {
		yyb201 = r.CheckBreak()
	}
	if yyb201 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ListMeta = pkg1_unversioned.ListMeta{}
	} else {
		yyv204 := &x.ListMeta
		yym205 := z.DecBinary()
		_ = yym205
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv204) {
		} else {
			z.DecFallback(yyv204, false)
		}
	}
	yyj201++
	if yyhl201 {
		yyb201 = yyj201 > l
	} else {
		yyb201 = r.CheckBreak()
	}
	if yyb201 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Items = nil
	} else {
		yyv206 := &x.Items
		yym207 := z.DecBinary()
		_ = yym207
		if false {
		} else {
			h.decSliceThirdPartyResource((*[]ThirdPartyResource)(yyv206), d)
		}
	}
	for {
		yyj201++
		if yyhl201 {
			yyb201 = yyj201 > l
		} else {
			yyb201 = r.CheckBreak()
		}
		if yyb201 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj201-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *APIVersion) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym208 := z.EncBinary()
		_ = yym208
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep209 := !z.EncBinary()
			yy2arr209 := z.EncBasicHandle().StructToArray
			var yyq209 [1]bool
			_, _, _ = yysep209, yyq209, yy2arr209
			const yyr209 bool = false
			yyq209[0] = x.Name != ""
			var yynn209 int
			if yyr209 || yy2arr209 {
				r.EncodeArrayStart(1)
			} else {
				yynn209 = 0
				for _, b := range yyq209 {
					if b {
						yynn209++
					}
				}
				r.EncodeMapStart(yynn209)
				yynn209 = 0
			}
			if yyr209 || yy2arr209 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq209[0] {
					yym211 := z.EncBinary()
					_ = yym211
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Name))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq209[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("name"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym212 := z.EncBinary()
					_ = yym212
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Name))
					}
				}
			}
			if yyr209 || yy2arr209 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *APIVersion) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym213 := z.DecBinary()
	_ = yym213
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct214 := r.ContainerType()
		if yyct214 == codecSelferValueTypeMap1234 {
			yyl214 := r.ReadMapStart()
			if yyl214 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl214, d)
			}
		} else if yyct214 == codecSelferValueTypeArray1234 {
			yyl214 := r.ReadArrayStart()
			if yyl214 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl214, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *APIVersion) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys215Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys215Slc
	var yyhl215 bool = l >= 0
	for yyj215 := 0; ; yyj215++ {
		if yyhl215 {
			if yyj215 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys215Slc = r.DecodeBytes(yys215Slc, true, true)
		yys215 := string(yys215Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys215 {
		case "name":
			if r.TryDecodeAsNil() {
				x.Name = ""
			} else {
				x.Name = string(r.DecodeString())
			}
		default:
			z.DecStructFieldNotFound(-1, yys215)
		} // end switch yys215
	} // end for yyj215
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *APIVersion) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj217 int
	var yyb217 bool
	var yyhl217 bool = l >= 0
	yyj217++
	if yyhl217 {
		yyb217 = yyj217 > l
	} else {
		yyb217 = r.CheckBreak()
	}
	if yyb217 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Name = ""
	} else {
		x.Name = string(r.DecodeString())
	}
	for {
		yyj217++
		if yyhl217 {
			yyb217 = yyj217 > l
		} else {
			yyb217 = r.CheckBreak()
		}
		if yyb217 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj217-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *ThirdPartyResourceData) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym219 := z.EncBinary()
		_ = yym219
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep220 := !z.EncBinary()
			yy2arr220 := z.EncBasicHandle().StructToArray
			var yyq220 [4]bool
			_, _, _ = yysep220, yyq220, yy2arr220
			const yyr220 bool = false
			yyq220[0] = x.Kind != ""
			yyq220[1] = x.APIVersion != ""
			yyq220[2] = true
			yyq220[3] = len(x.Data) != 0
			var yynn220 int
			if yyr220 || yy2arr220 {
				r.EncodeArrayStart(4)
			} else {
				yynn220 = 0
				for _, b := range yyq220 {
					if b {
						yynn220++
					}
				}
				r.EncodeMapStart(yynn220)
				yynn220 = 0
			}
			if yyr220 || yy2arr220 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq220[0] {
					yym222 := z.EncBinary()
					_ = yym222
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq220[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym223 := z.EncBinary()
					_ = yym223
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr220 || yy2arr220 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq220[1] {
					yym225 := z.EncBinary()
					_ = yym225
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq220[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym226 := z.EncBinary()
					_ = yym226
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr220 || yy2arr220 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq220[2] {
					yy228 := &x.ObjectMeta
					yy228.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq220[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy229 := &x.ObjectMeta
					yy229.CodecEncodeSelf(e)
				}
			}
			if yyr220 || yy2arr220 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq220[3] {
					if x.Data == nil {
						r.EncodeNil()
					} else {
						yym231 := z.EncBinary()
						_ = yym231
						if false {
						} else {
							r.EncodeStringBytes(codecSelferC_RAW1234, []byte(x.Data))
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq220[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("data"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.Data == nil {
						r.EncodeNil()
					} else {
						yym232 := z.EncBinary()
						_ = yym232
						if false {
						} else {
							r.EncodeStringBytes(codecSelferC_RAW1234, []byte(x.Data))
						}
					}
				}
			}
			if yyr220 || yy2arr220 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *ThirdPartyResourceData) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym233 := z.DecBinary()
	_ = yym233
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct234 := r.ContainerType()
		if yyct234 == codecSelferValueTypeMap1234 {
			yyl234 := r.ReadMapStart()
			if yyl234 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl234, d)
			}
		} else if yyct234 == codecSelferValueTypeArray1234 {
			yyl234 := r.ReadArrayStart()
			if yyl234 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl234, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *ThirdPartyResourceData) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys235Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys235Slc
	var yyhl235 bool = l >= 0
	for yyj235 := 0; ; yyj235++ {
		if yyhl235 {
			if yyj235 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys235Slc = r.DecodeBytes(yys235Slc, true, true)
		yys235 := string(yys235Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys235 {
		case "kind":
			if r.TryDecodeAsNil() {
				x.Kind = ""
			} else {
				x.Kind = string(r.DecodeString())
			}
		case "apiVersion":
			if r.TryDecodeAsNil() {
				x.APIVersion = ""
			} else {
				x.APIVersion = string(r.DecodeString())
			}
		case "metadata":
			if r.TryDecodeAsNil() {
				x.ObjectMeta = pkg2_api.ObjectMeta{}
			} else {
				yyv238 := &x.ObjectMeta
				yyv238.CodecDecodeSelf(d)
			}
		case "data":
			if r.TryDecodeAsNil() {
				x.Data = nil
			} else {
				yyv239 := &x.Data
				yym240 := z.DecBinary()
				_ = yym240
				if false {
				} else {
					*yyv239 = r.DecodeBytes(*(*[]byte)(yyv239), false, false)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys235)
		} // end switch yys235
	} // end for yyj235
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *ThirdPartyResourceData) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj241 int
	var yyb241 bool
	var yyhl241 bool = l >= 0
	yyj241++
	if yyhl241 {
		yyb241 = yyj241 > l
	} else {
		yyb241 = r.CheckBreak()
	}
	if yyb241 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj241++
	if yyhl241 {
		yyb241 = yyj241 > l
	} else {
		yyb241 = r.CheckBreak()
	}
	if yyb241 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj241++
	if yyhl241 {
		yyb241 = yyj241 > l
	} else {
		yyb241 = r.CheckBreak()
	}
	if yyb241 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ObjectMeta = pkg2_api.ObjectMeta{}
	} else {
		yyv244 := &x.ObjectMeta
		yyv244.CodecDecodeSelf(d)
	}
	yyj241++
	if yyhl241 {
		yyb241 = yyj241 > l
	} else {
		yyb241 = r.CheckBreak()
	}
	if yyb241 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Data = nil
	} else {
		yyv245 := &x.Data
		yym246 := z.DecBinary()
		_ = yym246
		if false {
		} else {
			*yyv245 = r.DecodeBytes(*(*[]byte)(yyv245), false, false)
		}
	}
	for {
		yyj241++
		if yyhl241 {
			yyb241 = yyj241 > l
		} else {
			yyb241 = r.CheckBreak()
		}
		if yyb241 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj241-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *Deployment) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym247 := z.EncBinary()
		_ = yym247
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep248 := !z.EncBinary()
			yy2arr248 := z.EncBasicHandle().StructToArray
			var yyq248 [5]bool
			_, _, _ = yysep248, yyq248, yy2arr248
			const yyr248 bool = false
			yyq248[0] = x.Kind != ""
			yyq248[1] = x.APIVersion != ""
			yyq248[2] = true
			yyq248[3] = true
			yyq248[4] = true
			var yynn248 int
			if yyr248 || yy2arr248 {
				r.EncodeArrayStart(5)
			} else {
				yynn248 = 0
				for _, b := range yyq248 {
					if b {
						yynn248++
					}
				}
				r.EncodeMapStart(yynn248)
				yynn248 = 0
			}
			if yyr248 || yy2arr248 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq248[0] {
					yym250 := z.EncBinary()
					_ = yym250
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq248[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym251 := z.EncBinary()
					_ = yym251
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr248 || yy2arr248 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq248[1] {
					yym253 := z.EncBinary()
					_ = yym253
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq248[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym254 := z.EncBinary()
					_ = yym254
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr248 || yy2arr248 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq248[2] {
					yy256 := &x.ObjectMeta
					yy256.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq248[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy257 := &x.ObjectMeta
					yy257.CodecEncodeSelf(e)
				}
			}
			if yyr248 || yy2arr248 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq248[3] {
					yy259 := &x.Spec
					yy259.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq248[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("spec"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy260 := &x.Spec
					yy260.CodecEncodeSelf(e)
				}
			}
			if yyr248 || yy2arr248 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq248[4] {
					yy262 := &x.Status
					yy262.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq248[4] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("status"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy263 := &x.Status
					yy263.CodecEncodeSelf(e)
				}
			}
			if yyr248 || yy2arr248 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *Deployment) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym264 := z.DecBinary()
	_ = yym264
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct265 := r.ContainerType()
		if yyct265 == codecSelferValueTypeMap1234 {
			yyl265 := r.ReadMapStart()
			if yyl265 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl265, d)
			}
		} else if yyct265 == codecSelferValueTypeArray1234 {
			yyl265 := r.ReadArrayStart()
			if yyl265 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl265, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *Deployment) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys266Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys266Slc
	var yyhl266 bool = l >= 0
	for yyj266 := 0; ; yyj266++ {
		if yyhl266 {
			if yyj266 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys266Slc = r.DecodeBytes(yys266Slc, true, true)
		yys266 := string(yys266Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys266 {
		case "kind":
			if r.TryDecodeAsNil() {
				x.Kind = ""
			} else {
				x.Kind = string(r.DecodeString())
			}
		case "apiVersion":
			if r.TryDecodeAsNil() {
				x.APIVersion = ""
			} else {
				x.APIVersion = string(r.DecodeString())
			}
		case "metadata":
			if r.TryDecodeAsNil() {
				x.ObjectMeta = pkg2_api.ObjectMeta{}
			} else {
				yyv269 := &x.ObjectMeta
				yyv269.CodecDecodeSelf(d)
			}
		case "spec":
			if r.TryDecodeAsNil() {
				x.Spec = DeploymentSpec{}
			} else {
				yyv270 := &x.Spec
				yyv270.CodecDecodeSelf(d)
			}
		case "status":
			if r.TryDecodeAsNil() {
				x.Status = DeploymentStatus{}
			} else {
				yyv271 := &x.Status
				yyv271.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys266)
		} // end switch yys266
	} // end for yyj266
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *Deployment) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj272 int
	var yyb272 bool
	var yyhl272 bool = l >= 0
	yyj272++
	if yyhl272 {
		yyb272 = yyj272 > l
	} else {
		yyb272 = r.CheckBreak()
	}
	if yyb272 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj272++
	if yyhl272 {
		yyb272 = yyj272 > l
	} else {
		yyb272 = r.CheckBreak()
	}
	if yyb272 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj272++
	if yyhl272 {
		yyb272 = yyj272 > l
	} else {
		yyb272 = r.CheckBreak()
	}
	if yyb272 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ObjectMeta = pkg2_api.ObjectMeta{}
	} else {
		yyv275 := &x.ObjectMeta
		yyv275.CodecDecodeSelf(d)
	}
	yyj272++
	if yyhl272 {
		yyb272 = yyj272 > l
	} else {
		yyb272 = r.CheckBreak()
	}
	if yyb272 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Spec = DeploymentSpec{}
	} else {
		yyv276 := &x.Spec
		yyv276.CodecDecodeSelf(d)
	}
	yyj272++
	if yyhl272 {
		yyb272 = yyj272 > l
	} else {
		yyb272 = r.CheckBreak()
	}
	if yyb272 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Status = DeploymentStatus{}
	} else {
		yyv277 := &x.Status
		yyv277.CodecDecodeSelf(d)
	}
	for {
		yyj272++
		if yyhl272 {
			yyb272 = yyj272 > l
		} else {
			yyb272 = r.CheckBreak()
		}
		if yyb272 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj272-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *DeploymentSpec) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym278 := z.EncBinary()
		_ = yym278
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep279 := !z.EncBinary()
			yy2arr279 := z.EncBasicHandle().StructToArray
			var yyq279 [8]bool
			_, _, _ = yysep279, yyq279, yy2arr279
			const yyr279 bool = false
			yyq279[0] = x.Replicas != 0
			yyq279[1] = x.Selector != nil
			yyq279[3] = true
			yyq279[4] = x.MinReadySeconds != 0
			yyq279[5] = x.RevisionHistoryLimit != nil
			yyq279[6] = x.Paused != false
			yyq279[7] = x.RollbackTo != nil
			var yynn279 int
			if yyr279 || yy2arr279 {
				r.EncodeArrayStart(8)
			} else {
				yynn279 = 1
				for _, b := range yyq279 {
					if b {
						yynn279++
					}
				}
				r.EncodeMapStart(yynn279)
				yynn279 = 0
			}
			if yyr279 || yy2arr279 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq279[0] {
					yym281 := z.EncBinary()
					_ = yym281
					if false {
					} else {
						r.EncodeInt(int64(x.Replicas))
					}
				} else {
					r.EncodeInt(0)
				}
			} else {
				if yyq279[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("replicas"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym282 := z.EncBinary()
					_ = yym282
					if false {
					} else {
						r.EncodeInt(int64(x.Replicas))
					}
				}
			}
			if yyr279 || yy2arr279 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq279[1] {
					if x.Selector == nil {
						r.EncodeNil()
					} else {
						yym284 := z.EncBinary()
						_ = yym284
						if false {
						} else if z.HasExtensions() && z.EncExt(x.Selector) {
						} else {
							z.EncFallback(x.Selector)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq279[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("selector"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.Selector == nil {
						r.EncodeNil()
					} else {
						yym285 := z.EncBinary()
						_ = yym285
						if false {
						} else if z.HasExtensions() && z.EncExt(x.Selector) {
						} else {
							z.EncFallback(x.Selector)
						}
					}
				}
			}
			if yyr279 || yy2arr279 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yy287 := &x.Template
				yy287.CodecEncodeSelf(e)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("template"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yy288 := &x.Template
				yy288.CodecEncodeSelf(e)
			}
			if yyr279 || yy2arr279 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq279[3] {
					yy290 := &x.Strategy
					yy290.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq279[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("strategy"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy291 := &x.Strategy
					yy291.CodecEncodeSelf(e)
				}
			}
			if yyr279 || yy2arr279 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq279[4] {
					yym293 := z.EncBinary()
					_ = yym293
					if false {
					} else {
						r.EncodeInt(int64(x.MinReadySeconds))
					}
				} else {
					r.EncodeInt(0)
				}
			} else {
				if yyq279[4] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("minReadySeconds"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym294 := z.EncBinary()
					_ = yym294
					if false {
					} else {
						r.EncodeInt(int64(x.MinReadySeconds))
					}
				}
			}
			if yyr279 || yy2arr279 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq279[5] {
					if x.RevisionHistoryLimit == nil {
						r.EncodeNil()
					} else {
						yy296 := *x.RevisionHistoryLimit
						yym297 := z.EncBinary()
						_ = yym297
						if false {
						} else {
							r.EncodeInt(int64(yy296))
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq279[5] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("revisionHistoryLimit"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.RevisionHistoryLimit == nil {
						r.EncodeNil()
					} else {
						yy298 := *x.RevisionHistoryLimit
						yym299 := z.EncBinary()
						_ = yym299
						if false {
						} else {
							r.EncodeInt(int64(yy298))
						}
					}
				}
			}
			if yyr279 || yy2arr279 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq279[6] {
					yym301 := z.EncBinary()
					_ = yym301
					if false {
					} else {
						r.EncodeBool(bool(x.Paused))
					}
				} else {
					r.EncodeBool(false)
				}
			} else {
				if yyq279[6] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("paused"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym302 := z.EncBinary()
					_ = yym302
					if false {
					} else {
						r.EncodeBool(bool(x.Paused))
					}
				}
			}
			if yyr279 || yy2arr279 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq279[7] {
					if x.RollbackTo == nil {
						r.EncodeNil()
					} else {
						x.RollbackTo.CodecEncodeSelf(e)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq279[7] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("rollbackTo"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.RollbackTo == nil {
						r.EncodeNil()
					} else {
						x.RollbackTo.CodecEncodeSelf(e)
					}
				}
			}
			if yyr279 || yy2arr279 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *DeploymentSpec) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym304 := z.DecBinary()
	_ = yym304
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct305 := r.ContainerType()
		if yyct305 == codecSelferValueTypeMap1234 {
			yyl305 := r.ReadMapStart()
			if yyl305 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl305, d)
			}
		} else if yyct305 == codecSelferValueTypeArray1234 {
			yyl305 := r.ReadArrayStart()
			if yyl305 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl305, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *DeploymentSpec) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys306Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys306Slc
	var yyhl306 bool = l >= 0
	for yyj306 := 0; ; yyj306++ {
		if yyhl306 {
			if yyj306 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys306Slc = r.DecodeBytes(yys306Slc, true, true)
		yys306 := string(yys306Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys306 {
		case "replicas":
			if r.TryDecodeAsNil() {
				x.Replicas = 0
			} else {
				x.Replicas = int32(r.DecodeInt(32))
			}
		case "selector":
			if r.TryDecodeAsNil() {
				if x.Selector != nil {
					x.Selector = nil
				}
			} else {
				if x.Selector == nil {
					x.Selector = new(pkg1_unversioned.LabelSelector)
				}
				yym309 := z.DecBinary()
				_ = yym309
				if false {
				} else if z.HasExtensions() && z.DecExt(x.Selector) {
				} else {
					z.DecFallback(x.Selector, false)
				}
			}
		case "template":
			if r.TryDecodeAsNil() {
				x.Template = pkg2_api.PodTemplateSpec{}
			} else {
				yyv310 := &x.Template
				yyv310.CodecDecodeSelf(d)
			}
		case "strategy":
			if r.TryDecodeAsNil() {
				x.Strategy = DeploymentStrategy{}
			} else {
				yyv311 := &x.Strategy
				yyv311.CodecDecodeSelf(d)
			}
		case "minReadySeconds":
			if r.TryDecodeAsNil() {
				x.MinReadySeconds = 0
			} else {
				x.MinReadySeconds = int32(r.DecodeInt(32))
			}
		case "revisionHistoryLimit":
			if r.TryDecodeAsNil() {
				if x.RevisionHistoryLimit != nil {
					x.RevisionHistoryLimit = nil
				}
			} else {
				if x.RevisionHistoryLimit == nil {
					x.RevisionHistoryLimit = new(int32)
				}
				yym314 := z.DecBinary()
				_ = yym314
				if false {
				} else {
					*((*int32)(x.RevisionHistoryLimit)) = int32(r.DecodeInt(32))
				}
			}
		case "paused":
			if r.TryDecodeAsNil() {
				x.Paused = false
			} else {
				x.Paused = bool(r.DecodeBool())
			}
		case "rollbackTo":
			if r.TryDecodeAsNil() {
				if x.RollbackTo != nil {
					x.RollbackTo = nil
				}
			} else {
				if x.RollbackTo == nil {
					x.RollbackTo = new(RollbackConfig)
				}
				x.RollbackTo.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys306)
		} // end switch yys306
	} // end for yyj306
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *DeploymentSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj317 int
	var yyb317 bool
	var yyhl317 bool = l >= 0
	yyj317++
	if yyhl317 {
		yyb317 = yyj317 > l
	} else {
		yyb317 = r.CheckBreak()
	}
	if yyb317 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Replicas = 0
	} else {
		x.Replicas = int32(r.DecodeInt(32))
	}
	yyj317++
	if yyhl317 {
		yyb317 = yyj317 > l
	} else {
		yyb317 = r.CheckBreak()
	}
	if yyb317 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		if x.Selector != nil {
			x.Selector = nil
		}
	} else {
		if x.Selector == nil {
			x.Selector = new(pkg1_unversioned.LabelSelector)
		}
		yym320 := z.DecBinary()
		_ = yym320
		if false {
		} else if z.HasExtensions() && z.DecExt(x.Selector) {
		} else {
			z.DecFallback(x.Selector, false)
		}
	}
	yyj317++
	if yyhl317 {
		yyb317 = yyj317 > l
	} else {
		yyb317 = r.CheckBreak()
	}
	if yyb317 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Template = pkg2_api.PodTemplateSpec{}
	} else {
		yyv321 := &x.Template
		yyv321.CodecDecodeSelf(d)
	}
	yyj317++
	if yyhl317 {
		yyb317 = yyj317 > l
	} else {
		yyb317 = r.CheckBreak()
	}
	if yyb317 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Strategy = DeploymentStrategy{}
	} else {
		yyv322 := &x.Strategy
		yyv322.CodecDecodeSelf(d)
	}
	yyj317++
	if yyhl317 {
		yyb317 = yyj317 > l
	} else {
		yyb317 = r.CheckBreak()
	}
	if yyb317 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.MinReadySeconds = 0
	} else {
		x.MinReadySeconds = int32(r.DecodeInt(32))
	}
	yyj317++
	if yyhl317 {
		yyb317 = yyj317 > l
	} else {
		yyb317 = r.CheckBreak()
	}
	if yyb317 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		if x.RevisionHistoryLimit != nil {
			x.RevisionHistoryLimit = nil
		}
	} else {
		if x.RevisionHistoryLimit == nil {
			x.RevisionHistoryLimit = new(int32)
		}
		yym325 := z.DecBinary()
		_ = yym325
		if false {
		} else {
			*((*int32)(x.RevisionHistoryLimit)) = int32(r.DecodeInt(32))
		}
	}
	yyj317++
	if yyhl317 {
		yyb317 = yyj317 > l
	} else {
		yyb317 = r.CheckBreak()
	}
	if yyb317 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Paused = false
	} else {
		x.Paused = bool(r.DecodeBool())
	}
	yyj317++
	if yyhl317 {
		yyb317 = yyj317 > l
	} else {
		yyb317 = r.CheckBreak()
	}
	if yyb317 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		if x.RollbackTo != nil {
			x.RollbackTo = nil
		}
	} else {
		if x.RollbackTo == nil {
			x.RollbackTo = new(RollbackConfig)
		}
		x.RollbackTo.CodecDecodeSelf(d)
	}
	for {
		yyj317++
		if yyhl317 {
			yyb317 = yyj317 > l
		} else {
			yyb317 = r.CheckBreak()
		}
		if yyb317 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj317-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *DeploymentRollback) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym328 := z.EncBinary()
		_ = yym328
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep329 := !z.EncBinary()
			yy2arr329 := z.EncBasicHandle().StructToArray
			var yyq329 [5]bool
			_, _, _ = yysep329, yyq329, yy2arr329
			const yyr329 bool = false
			yyq329[0] = x.Kind != ""
			yyq329[1] = x.APIVersion != ""
			yyq329[3] = len(x.UpdatedAnnotations) != 0
			var yynn329 int
			if yyr329 || yy2arr329 {
				r.EncodeArrayStart(5)
			} else {
				yynn329 = 2
				for _, b := range yyq329 {
					if b {
						yynn329++
					}
				}
				r.EncodeMapStart(yynn329)
				yynn329 = 0
			}
			if yyr329 || yy2arr329 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq329[0] {
					yym331 := z.EncBinary()
					_ = yym331
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq329[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym332 := z.EncBinary()
					_ = yym332
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr329 || yy2arr329 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq329[1] {
					yym334 := z.EncBinary()
					_ = yym334
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq329[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym335 := z.EncBinary()
					_ = yym335
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr329 || yy2arr329 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym337 := z.EncBinary()
				_ = yym337
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF81234, string(x.Name))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("name"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yym338 := z.EncBinary()
				_ = yym338
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF81234, string(x.Name))
				}
			}
			if yyr329 || yy2arr329 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq329[3] {
					if x.UpdatedAnnotations == nil {
						r.EncodeNil()
					} else {
						yym340 := z.EncBinary()
						_ = yym340
						if false {
						} else {
							z.F.EncMapStringStringV(x.UpdatedAnnotations, false, e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq329[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("updatedAnnotations"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.UpdatedAnnotations == nil {
						r.EncodeNil()
					} else {
						yym341 := z.EncBinary()
						_ = yym341
						if false {
						} else {
							z.F.EncMapStringStringV(x.UpdatedAnnotations, false, e)
						}
					}
				}
			}
			if yyr329 || yy2arr329 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yy343 := &x.RollbackTo
				yy343.CodecEncodeSelf(e)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("rollbackTo"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yy344 := &x.RollbackTo
				yy344.CodecEncodeSelf(e)
			}
			if yyr329 || yy2arr329 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *DeploymentRollback) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym345 := z.DecBinary()
	_ = yym345
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct346 := r.ContainerType()
		if yyct346 == codecSelferValueTypeMap1234 {
			yyl346 := r.ReadMapStart()
			if yyl346 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl346, d)
			}
		} else if yyct346 == codecSelferValueTypeArray1234 {
			yyl346 := r.ReadArrayStart()
			if yyl346 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl346, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *DeploymentRollback) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys347Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys347Slc
	var yyhl347 bool = l >= 0
	for yyj347 := 0; ; yyj347++ {
		if yyhl347 {
			if yyj347 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys347Slc = r.DecodeBytes(yys347Slc, true, true)
		yys347 := string(yys347Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys347 {
		case "kind":
			if r.TryDecodeAsNil() {
				x.Kind = ""
			} else {
				x.Kind = string(r.DecodeString())
			}
		case "apiVersion":
			if r.TryDecodeAsNil() {
				x.APIVersion = ""
			} else {
				x.APIVersion = string(r.DecodeString())
			}
		case "name":
			if r.TryDecodeAsNil() {
				x.Name = ""
			} else {
				x.Name = string(r.DecodeString())
			}
		case "updatedAnnotations":
			if r.TryDecodeAsNil() {
				x.UpdatedAnnotations = nil
			} else {
				yyv351 := &x.UpdatedAnnotations
				yym352 := z.DecBinary()
				_ = yym352
				if false {
				} else {
					z.F.DecMapStringStringX(yyv351, false, d)
				}
			}
		case "rollbackTo":
			if r.TryDecodeAsNil() {
				x.RollbackTo = RollbackConfig{}
			} else {
				yyv353 := &x.RollbackTo
				yyv353.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys347)
		} // end switch yys347
	} // end for yyj347
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *DeploymentRollback) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj354 int
	var yyb354 bool
	var yyhl354 bool = l >= 0
	yyj354++
	if yyhl354 {
		yyb354 = yyj354 > l
	} else {
		yyb354 = r.CheckBreak()
	}
	if yyb354 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj354++
	if yyhl354 {
		yyb354 = yyj354 > l
	} else {
		yyb354 = r.CheckBreak()
	}
	if yyb354 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj354++
	if yyhl354 {
		yyb354 = yyj354 > l
	} else {
		yyb354 = r.CheckBreak()
	}
	if yyb354 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Name = ""
	} else {
		x.Name = string(r.DecodeString())
	}
	yyj354++
	if yyhl354 {
		yyb354 = yyj354 > l
	} else {
		yyb354 = r.CheckBreak()
	}
	if yyb354 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.UpdatedAnnotations = nil
	} else {
		yyv358 := &x.UpdatedAnnotations
		yym359 := z.DecBinary()
		_ = yym359
		if false {
		} else {
			z.F.DecMapStringStringX(yyv358, false, d)
		}
	}
	yyj354++
	if yyhl354 {
		yyb354 = yyj354 > l
	} else {
		yyb354 = r.CheckBreak()
	}
	if yyb354 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.RollbackTo = RollbackConfig{}
	} else {
		yyv360 := &x.RollbackTo
		yyv360.CodecDecodeSelf(d)
	}
	for {
		yyj354++
		if yyhl354 {
			yyb354 = yyj354 > l
		} else {
			yyb354 = r.CheckBreak()
		}
		if yyb354 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj354-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *RollbackConfig) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym361 := z.EncBinary()
		_ = yym361
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep362 := !z.EncBinary()
			yy2arr362 := z.EncBasicHandle().StructToArray
			var yyq362 [1]bool
			_, _, _ = yysep362, yyq362, yy2arr362
			const yyr362 bool = false
			yyq362[0] = x.Revision != 0
			var yynn362 int
			if yyr362 || yy2arr362 {
				r.EncodeArrayStart(1)
			} else {
				yynn362 = 0
				for _, b := range yyq362 {
					if b {
						yynn362++
					}
				}
				r.EncodeMapStart(yynn362)
				yynn362 = 0
			}
			if yyr362 || yy2arr362 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq362[0] {
					yym364 := z.EncBinary()
					_ = yym364
					if false {
					} else {
						r.EncodeInt(int64(x.Revision))
					}
				} else {
					r.EncodeInt(0)
				}
			} else {
				if yyq362[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("revision"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym365 := z.EncBinary()
					_ = yym365
					if false {
					} else {
						r.EncodeInt(int64(x.Revision))
					}
				}
			}
			if yyr362 || yy2arr362 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *RollbackConfig) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym366 := z.DecBinary()
	_ = yym366
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct367 := r.ContainerType()
		if yyct367 == codecSelferValueTypeMap1234 {
			yyl367 := r.ReadMapStart()
			if yyl367 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl367, d)
			}
		} else if yyct367 == codecSelferValueTypeArray1234 {
			yyl367 := r.ReadArrayStart()
			if yyl367 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl367, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *RollbackConfig) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys368Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys368Slc
	var yyhl368 bool = l >= 0
	for yyj368 := 0; ; yyj368++ {
		if yyhl368 {
			if yyj368 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys368Slc = r.DecodeBytes(yys368Slc, true, true)
		yys368 := string(yys368Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys368 {
		case "revision":
			if r.TryDecodeAsNil() {
				x.Revision = 0
			} else {
				x.Revision = int64(r.DecodeInt(64))
			}
		default:
			z.DecStructFieldNotFound(-1, yys368)
		} // end switch yys368
	} // end for yyj368
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *RollbackConfig) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj370 int
	var yyb370 bool
	var yyhl370 bool = l >= 0
	yyj370++
	if yyhl370 {
		yyb370 = yyj370 > l
	} else {
		yyb370 = r.CheckBreak()
	}
	if yyb370 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Revision = 0
	} else {
		x.Revision = int64(r.DecodeInt(64))
	}
	for {
		yyj370++
		if yyhl370 {
			yyb370 = yyj370 > l
		} else {
			yyb370 = r.CheckBreak()
		}
		if yyb370 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj370-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *DeploymentStrategy) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym372 := z.EncBinary()
		_ = yym372
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep373 := !z.EncBinary()
			yy2arr373 := z.EncBasicHandle().StructToArray
			var yyq373 [2]bool
			_, _, _ = yysep373, yyq373, yy2arr373
			const yyr373 bool = false
			yyq373[0] = x.Type != ""
			yyq373[1] = x.RollingUpdate != nil
			var yynn373 int
			if yyr373 || yy2arr373 {
				r.EncodeArrayStart(2)
			} else {
				yynn373 = 0
				for _, b := range yyq373 {
					if b {
						yynn373++
					}
				}
				r.EncodeMapStart(yynn373)
				yynn373 = 0
			}
			if yyr373 || yy2arr373 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq373[0] {
					x.Type.CodecEncodeSelf(e)
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq373[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("type"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					x.Type.CodecEncodeSelf(e)
				}
			}
			if yyr373 || yy2arr373 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq373[1] {
					if x.RollingUpdate == nil {
						r.EncodeNil()
					} else {
						x.RollingUpdate.CodecEncodeSelf(e)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq373[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("rollingUpdate"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.RollingUpdate == nil {
						r.EncodeNil()
					} else {
						x.RollingUpdate.CodecEncodeSelf(e)
					}
				}
			}
			if yyr373 || yy2arr373 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *DeploymentStrategy) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym376 := z.DecBinary()
	_ = yym376
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct377 := r.ContainerType()
		if yyct377 == codecSelferValueTypeMap1234 {
			yyl377 := r.ReadMapStart()
			if yyl377 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl377, d)
			}
		} else if yyct377 == codecSelferValueTypeArray1234 {
			yyl377 := r.ReadArrayStart()
			if yyl377 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl377, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *DeploymentStrategy) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys378Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys378Slc
	var yyhl378 bool = l >= 0
	for yyj378 := 0; ; yyj378++ {
		if yyhl378 {
			if yyj378 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys378Slc = r.DecodeBytes(yys378Slc, true, true)
		yys378 := string(yys378Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys378 {
		case "type":
			if r.TryDecodeAsNil() {
				x.Type = ""
			} else {
				x.Type = DeploymentStrategyType(r.DecodeString())
			}
		case "rollingUpdate":
			if r.TryDecodeAsNil() {
				if x.RollingUpdate != nil {
					x.RollingUpdate = nil
				}
			} else {
				if x.RollingUpdate == nil {
					x.RollingUpdate = new(RollingUpdateDeployment)
				}
				x.RollingUpdate.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys378)
		} // end switch yys378
	} // end for yyj378
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *DeploymentStrategy) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj381 int
	var yyb381 bool
	var yyhl381 bool = l >= 0
	yyj381++
	if yyhl381 {
		yyb381 = yyj381 > l
	} else {
		yyb381 = r.CheckBreak()
	}
	if yyb381 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Type = ""
	} else {
		x.Type = DeploymentStrategyType(r.DecodeString())
	}
	yyj381++
	if yyhl381 {
		yyb381 = yyj381 > l
	} else {
		yyb381 = r.CheckBreak()
	}
	if yyb381 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		if x.RollingUpdate != nil {
			x.RollingUpdate = nil
		}
	} else {
		if x.RollingUpdate == nil {
			x.RollingUpdate = new(RollingUpdateDeployment)
		}
		x.RollingUpdate.CodecDecodeSelf(d)
	}
	for {
		yyj381++
		if yyhl381 {
			yyb381 = yyj381 > l
		} else {
			yyb381 = r.CheckBreak()
		}
		if yyb381 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj381-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x DeploymentStrategyType) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	yym384 := z.EncBinary()
	_ = yym384
	if false {
	} else if z.HasExtensions() && z.EncExt(x) {
	} else {
		r.EncodeString(codecSelferC_UTF81234, string(x))
	}
}

func (x *DeploymentStrategyType) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym385 := z.DecBinary()
	_ = yym385
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		*((*string)(x)) = r.DecodeString()
	}
}

func (x *RollingUpdateDeployment) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym386 := z.EncBinary()
		_ = yym386
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep387 := !z.EncBinary()
			yy2arr387 := z.EncBasicHandle().StructToArray
			var yyq387 [2]bool
			_, _, _ = yysep387, yyq387, yy2arr387
			const yyr387 bool = false
			yyq387[0] = true
			yyq387[1] = true
			var yynn387 int
			if yyr387 || yy2arr387 {
				r.EncodeArrayStart(2)
			} else {
				yynn387 = 0
				for _, b := range yyq387 {
					if b {
						yynn387++
					}
				}
				r.EncodeMapStart(yynn387)
				yynn387 = 0
			}
			if yyr387 || yy2arr387 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq387[0] {
					yy389 := &x.MaxUnavailable
					yym390 := z.EncBinary()
					_ = yym390
					if false {
					} else if z.HasExtensions() && z.EncExt(yy389) {
					} else if !yym390 && z.IsJSONHandle() {
						z.EncJSONMarshal(yy389)
					} else {
						z.EncFallback(yy389)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq387[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("maxUnavailable"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy391 := &x.MaxUnavailable
					yym392 := z.EncBinary()
					_ = yym392
					if false {
					} else if z.HasExtensions() && z.EncExt(yy391) {
					} else if !yym392 && z.IsJSONHandle() {
						z.EncJSONMarshal(yy391)
					} else {
						z.EncFallback(yy391)
					}
				}
			}
			if yyr387 || yy2arr387 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq387[1] {
					yy394 := &x.MaxSurge
					yym395 := z.EncBinary()
					_ = yym395
					if false {
					} else if z.HasExtensions() && z.EncExt(yy394) {
					} else if !yym395 && z.IsJSONHandle() {
						z.EncJSONMarshal(yy394)
					} else {
						z.EncFallback(yy394)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq387[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("maxSurge"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy396 := &x.MaxSurge
					yym397 := z.EncBinary()
					_ = yym397
					if false {
					} else if z.HasExtensions() && z.EncExt(yy396) {
					} else if !yym397 && z.IsJSONHandle() {
						z.EncJSONMarshal(yy396)
					} else {
						z.EncFallback(yy396)
					}
				}
			}
			if yyr387 || yy2arr387 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *RollingUpdateDeployment) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym398 := z.DecBinary()
	_ = yym398
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct399 := r.ContainerType()
		if yyct399 == codecSelferValueTypeMap1234 {
			yyl399 := r.ReadMapStart()
			if yyl399 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl399, d)
			}
		} else if yyct399 == codecSelferValueTypeArray1234 {
			yyl399 := r.ReadArrayStart()
			if yyl399 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl399, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *RollingUpdateDeployment) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys400Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys400Slc
	var yyhl400 bool = l >= 0
	for yyj400 := 0; ; yyj400++ {
		if yyhl400 {
			if yyj400 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys400Slc = r.DecodeBytes(yys400Slc, true, true)
		yys400 := string(yys400Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys400 {
		case "maxUnavailable":
			if r.TryDecodeAsNil() {
				x.MaxUnavailable = pkg5_intstr.IntOrString{}
			} else {
				yyv401 := &x.MaxUnavailable
				yym402 := z.DecBinary()
				_ = yym402
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv401) {
				} else if !yym402 && z.IsJSONHandle() {
					z.DecJSONUnmarshal(yyv401)
				} else {
					z.DecFallback(yyv401, false)
				}
			}
		case "maxSurge":
			if r.TryDecodeAsNil() {
				x.MaxSurge = pkg5_intstr.IntOrString{}
			} else {
				yyv403 := &x.MaxSurge
				yym404 := z.DecBinary()
				_ = yym404
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv403) {
				} else if !yym404 && z.IsJSONHandle() {
					z.DecJSONUnmarshal(yyv403)
				} else {
					z.DecFallback(yyv403, false)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys400)
		} // end switch yys400
	} // end for yyj400
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *RollingUpdateDeployment) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj405 int
	var yyb405 bool
	var yyhl405 bool = l >= 0
	yyj405++
	if yyhl405 {
		yyb405 = yyj405 > l
	} else {
		yyb405 = r.CheckBreak()
	}
	if yyb405 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.MaxUnavailable = pkg5_intstr.IntOrString{}
	} else {
		yyv406 := &x.MaxUnavailable
		yym407 := z.DecBinary()
		_ = yym407
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv406) {
		} else if !yym407 && z.IsJSONHandle() {
			z.DecJSONUnmarshal(yyv406)
		} else {
			z.DecFallback(yyv406, false)
		}
	}
	yyj405++
	if yyhl405 {
		yyb405 = yyj405 > l
	} else {
		yyb405 = r.CheckBreak()
	}
	if yyb405 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.MaxSurge = pkg5_intstr.IntOrString{}
	} else {
		yyv408 := &x.MaxSurge
		yym409 := z.DecBinary()
		_ = yym409
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv408) {
		} else if !yym409 && z.IsJSONHandle() {
			z.DecJSONUnmarshal(yyv408)
		} else {
			z.DecFallback(yyv408, false)
		}
	}
	for {
		yyj405++
		if yyhl405 {
			yyb405 = yyj405 > l
		} else {
			yyb405 = r.CheckBreak()
		}
		if yyb405 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj405-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *DeploymentStatus) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym410 := z.EncBinary()
		_ = yym410
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep411 := !z.EncBinary()
			yy2arr411 := z.EncBasicHandle().StructToArray
			var yyq411 [5]bool
			_, _, _ = yysep411, yyq411, yy2arr411
			const yyr411 bool = false
			yyq411[0] = x.ObservedGeneration != 0
			yyq411[1] = x.Replicas != 0
			yyq411[2] = x.UpdatedReplicas != 0
			yyq411[3] = x.AvailableReplicas != 0
			yyq411[4] = x.UnavailableReplicas != 0
			var yynn411 int
			if yyr411 || yy2arr411 {
				r.EncodeArrayStart(5)
			} else {
				yynn411 = 0
				for _, b := range yyq411 {
					if b {
						yynn411++
					}
				}
				r.EncodeMapStart(yynn411)
				yynn411 = 0
			}
			if yyr411 || yy2arr411 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq411[0] {
					yym413 := z.EncBinary()
					_ = yym413
					if false {
					} else {
						r.EncodeInt(int64(x.ObservedGeneration))
					}
				} else {
					r.EncodeInt(0)
				}
			} else {
				if yyq411[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("observedGeneration"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym414 := z.EncBinary()
					_ = yym414
					if false {
					} else {
						r.EncodeInt(int64(x.ObservedGeneration))
					}
				}
			}
			if yyr411 || yy2arr411 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq411[1] {
					yym416 := z.EncBinary()
					_ = yym416
					if false {
					} else {
						r.EncodeInt(int64(x.Replicas))
					}
				} else {
					r.EncodeInt(0)
				}
			} else {
				if yyq411[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("replicas"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym417 := z.EncBinary()
					_ = yym417
					if false {
					} else {
						r.EncodeInt(int64(x.Replicas))
					}
				}
			}
			if yyr411 || yy2arr411 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq411[2] {
					yym419 := z.EncBinary()
					_ = yym419
					if false {
					} else {
						r.EncodeInt(int64(x.UpdatedReplicas))
					}
				} else {
					r.EncodeInt(0)
				}
			} else {
				if yyq411[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("updatedReplicas"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym420 := z.EncBinary()
					_ = yym420
					if false {
					} else {
						r.EncodeInt(int64(x.UpdatedReplicas))
					}
				}
			}
			if yyr411 || yy2arr411 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq411[3] {
					yym422 := z.EncBinary()
					_ = yym422
					if false {
					} else {
						r.EncodeInt(int64(x.AvailableReplicas))
					}
				} else {
					r.EncodeInt(0)
				}
			} else {
				if yyq411[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("availableReplicas"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym423 := z.EncBinary()
					_ = yym423
					if false {
					} else {
						r.EncodeInt(int64(x.AvailableReplicas))
					}
				}
			}
			if yyr411 || yy2arr411 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq411[4] {
					yym425 := z.EncBinary()
					_ = yym425
					if false {
					} else {
						r.EncodeInt(int64(x.UnavailableReplicas))
					}
				} else {
					r.EncodeInt(0)
				}
			} else {
				if yyq411[4] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("unavailableReplicas"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym426 := z.EncBinary()
					_ = yym426
					if false {
					} else {
						r.EncodeInt(int64(x.UnavailableReplicas))
					}
				}
			}
			if yyr411 || yy2arr411 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *DeploymentStatus) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym427 := z.DecBinary()
	_ = yym427
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct428 := r.ContainerType()
		if yyct428 == codecSelferValueTypeMap1234 {
			yyl428 := r.ReadMapStart()
			if yyl428 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl428, d)
			}
		} else if yyct428 == codecSelferValueTypeArray1234 {
			yyl428 := r.ReadArrayStart()
			if yyl428 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl428, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *DeploymentStatus) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys429Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys429Slc
	var yyhl429 bool = l >= 0
	for yyj429 := 0; ; yyj429++ {
		if yyhl429 {
			if yyj429 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys429Slc = r.DecodeBytes(yys429Slc, true, true)
		yys429 := string(yys429Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys429 {
		case "observedGeneration":
			if r.TryDecodeAsNil() {
				x.ObservedGeneration = 0
			} else {
				x.ObservedGeneration = int64(r.DecodeInt(64))
			}
		case "replicas":
			if r.TryDecodeAsNil() {
				x.Replicas = 0
			} else {
				x.Replicas = int32(r.DecodeInt(32))
			}
		case "updatedReplicas":
			if r.TryDecodeAsNil() {
				x.UpdatedReplicas = 0
			} else {
				x.UpdatedReplicas = int32(r.DecodeInt(32))
			}
		case "availableReplicas":
			if r.TryDecodeAsNil() {
				x.AvailableReplicas = 0
			} else {
				x.AvailableReplicas = int32(r.DecodeInt(32))
			}
		case "unavailableReplicas":
			if r.TryDecodeAsNil() {
				x.UnavailableReplicas = 0
			} else {
				x.UnavailableReplicas = int32(r.DecodeInt(32))
			}
		default:
			z.DecStructFieldNotFound(-1, yys429)
		} // end switch yys429
	} // end for yyj429
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *DeploymentStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj435 int
	var yyb435 bool
	var yyhl435 bool = l >= 0
	yyj435++
	if yyhl435 {
		yyb435 = yyj435 > l
	} else {
		yyb435 = r.CheckBreak()
	}
	if yyb435 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ObservedGeneration = 0
	} else {
		x.ObservedGeneration = int64(r.DecodeInt(64))
	}
	yyj435++
	if yyhl435 {
		yyb435 = yyj435 > l
	} else {
		yyb435 = r.CheckBreak()
	}
	if yyb435 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Replicas = 0
	} else {
		x.Replicas = int32(r.DecodeInt(32))
	}
	yyj435++
	if yyhl435 {
		yyb435 = yyj435 > l
	} else {
		yyb435 = r.CheckBreak()
	}
	if yyb435 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.UpdatedReplicas = 0
	} else {
		x.UpdatedReplicas = int32(r.DecodeInt(32))
	}
	yyj435++
	if yyhl435 {
		yyb435 = yyj435 > l
	} else {
		yyb435 = r.CheckBreak()
	}
	if yyb435 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.AvailableReplicas = 0
	} else {
		x.AvailableReplicas = int32(r.DecodeInt(32))
	}
	yyj435++
	if yyhl435 {
		yyb435 = yyj435 > l
	} else {
		yyb435 = r.CheckBreak()
	}
	if yyb435 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.UnavailableReplicas = 0
	} else {
		x.UnavailableReplicas = int32(r.DecodeInt(32))
	}
	for {
		yyj435++
		if yyhl435 {
			yyb435 = yyj435 > l
		} else {
			yyb435 = r.CheckBreak()
		}
		if yyb435 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj435-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *DeploymentList) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym441 := z.EncBinary()
		_ = yym441
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep442 := !z.EncBinary()
			yy2arr442 := z.EncBasicHandle().StructToArray
			var yyq442 [4]bool
			_, _, _ = yysep442, yyq442, yy2arr442
			const yyr442 bool = false
			yyq442[0] = x.Kind != ""
			yyq442[1] = x.APIVersion != ""
			yyq442[2] = true
			var yynn442 int
			if yyr442 || yy2arr442 {
				r.EncodeArrayStart(4)
			} else {
				yynn442 = 1
				for _, b := range yyq442 {
					if b {
						yynn442++
					}
				}
				r.EncodeMapStart(yynn442)
				yynn442 = 0
			}
			if yyr442 || yy2arr442 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq442[0] {
					yym444 := z.EncBinary()
					_ = yym444
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq442[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym445 := z.EncBinary()
					_ = yym445
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr442 || yy2arr442 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq442[1] {
					yym447 := z.EncBinary()
					_ = yym447
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq442[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym448 := z.EncBinary()
					_ = yym448
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr442 || yy2arr442 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq442[2] {
					yy450 := &x.ListMeta
					yym451 := z.EncBinary()
					_ = yym451
					if false {
					} else if z.HasExtensions() && z.EncExt(yy450) {
					} else {
						z.EncFallback(yy450)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq442[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy452 := &x.ListMeta
					yym453 := z.EncBinary()
					_ = yym453
					if false {
					} else if z.HasExtensions() && z.EncExt(yy452) {
					} else {
						z.EncFallback(yy452)
					}
				}
			}
			if yyr442 || yy2arr442 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym455 := z.EncBinary()
					_ = yym455
					if false {
					} else {
						h.encSliceDeployment(([]Deployment)(x.Items), e)
					}
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("items"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym456 := z.EncBinary()
					_ = yym456
					if false {
					} else {
						h.encSliceDeployment(([]Deployment)(x.Items), e)
					}
				}
			}
			if yyr442 || yy2arr442 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *DeploymentList) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym457 := z.DecBinary()
	_ = yym457
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct458 := r.ContainerType()
		if yyct458 == codecSelferValueTypeMap1234 {
			yyl458 := r.ReadMapStart()
			if yyl458 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl458, d)
			}
		} else if yyct458 == codecSelferValueTypeArray1234 {
			yyl458 := r.ReadArrayStart()
			if yyl458 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl458, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *DeploymentList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys459Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys459Slc
	var yyhl459 bool = l >= 0
	for yyj459 := 0; ; yyj459++ {
		if yyhl459 {
			if yyj459 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys459Slc = r.DecodeBytes(yys459Slc, true, true)
		yys459 := string(yys459Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys459 {
		case "kind":
			if r.TryDecodeAsNil() {
				x.Kind = ""
			} else {
				x.Kind = string(r.DecodeString())
			}
		case "apiVersion":
			if r.TryDecodeAsNil() {
				x.APIVersion = ""
			} else {
				x.APIVersion = string(r.DecodeString())
			}
		case "metadata":
			if r.TryDecodeAsNil() {
				x.ListMeta = pkg1_unversioned.ListMeta{}
			} else {
				yyv462 := &x.ListMeta
				yym463 := z.DecBinary()
				_ = yym463
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv462) {
				} else {
					z.DecFallback(yyv462, false)
				}
			}
		case "items":
			if r.TryDecodeAsNil() {
				x.Items = nil
			} else {
				yyv464 := &x.Items
				yym465 := z.DecBinary()
				_ = yym465
				if false {
				} else {
					h.decSliceDeployment((*[]Deployment)(yyv464), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys459)
		} // end switch yys459
	} // end for yyj459
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *DeploymentList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj466 int
	var yyb466 bool
	var yyhl466 bool = l >= 0
	yyj466++
	if yyhl466 {
		yyb466 = yyj466 > l
	} else {
		yyb466 = r.CheckBreak()
	}
	if yyb466 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj466++
	if yyhl466 {
		yyb466 = yyj466 > l
	} else {
		yyb466 = r.CheckBreak()
	}
	if yyb466 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj466++
	if yyhl466 {
		yyb466 = yyj466 > l
	} else {
		yyb466 = r.CheckBreak()
	}
	if yyb466 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ListMeta = pkg1_unversioned.ListMeta{}
	} else {
		yyv469 := &x.ListMeta
		yym470 := z.DecBinary()
		_ = yym470
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv469) {
		} else {
			z.DecFallback(yyv469, false)
		}
	}
	yyj466++
	if yyhl466 {
		yyb466 = yyj466 > l
	} else {
		yyb466 = r.CheckBreak()
	}
	if yyb466 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Items = nil
	} else {
		yyv471 := &x.Items
		yym472 := z.DecBinary()
		_ = yym472
		if false {
		} else {
			h.decSliceDeployment((*[]Deployment)(yyv471), d)
		}
	}
	for {
		yyj466++
		if yyhl466 {
			yyb466 = yyj466 > l
		} else {
			yyb466 = r.CheckBreak()
		}
		if yyb466 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj466-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *DaemonSetSpec) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym473 := z.EncBinary()
		_ = yym473
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep474 := !z.EncBinary()
			yy2arr474 := z.EncBasicHandle().StructToArray
			var yyq474 [2]bool
			_, _, _ = yysep474, yyq474, yy2arr474
			const yyr474 bool = false
			yyq474[0] = x.Selector != nil
			var yynn474 int
			if yyr474 || yy2arr474 {
				r.EncodeArrayStart(2)
			} else {
				yynn474 = 1
				for _, b := range yyq474 {
					if b {
						yynn474++
					}
				}
				r.EncodeMapStart(yynn474)
				yynn474 = 0
			}
			if yyr474 || yy2arr474 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq474[0] {
					if x.Selector == nil {
						r.EncodeNil()
					} else {
						yym476 := z.EncBinary()
						_ = yym476
						if false {
						} else if z.HasExtensions() && z.EncExt(x.Selector) {
						} else {
							z.EncFallback(x.Selector)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq474[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("selector"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.Selector == nil {
						r.EncodeNil()
					} else {
						yym477 := z.EncBinary()
						_ = yym477
						if false {
						} else if z.HasExtensions() && z.EncExt(x.Selector) {
						} else {
							z.EncFallback(x.Selector)
						}
					}
				}
			}
			if yyr474 || yy2arr474 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yy479 := &x.Template
				yy479.CodecEncodeSelf(e)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("template"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yy480 := &x.Template
				yy480.CodecEncodeSelf(e)
			}
			if yyr474 || yy2arr474 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *DaemonSetSpec) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym481 := z.DecBinary()
	_ = yym481
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct482 := r.ContainerType()
		if yyct482 == codecSelferValueTypeMap1234 {
			yyl482 := r.ReadMapStart()
			if yyl482 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl482, d)
			}
		} else if yyct482 == codecSelferValueTypeArray1234 {
			yyl482 := r.ReadArrayStart()
			if yyl482 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl482, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *DaemonSetSpec) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys483Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys483Slc
	var yyhl483 bool = l >= 0
	for yyj483 := 0; ; yyj483++ {
		if yyhl483 {
			if yyj483 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys483Slc = r.DecodeBytes(yys483Slc, true, true)
		yys483 := string(yys483Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys483 {
		case "selector":
			if r.TryDecodeAsNil() {
				if x.Selector != nil {
					x.Selector = nil
				}
			} else {
				if x.Selector == nil {
					x.Selector = new(pkg1_unversioned.LabelSelector)
				}
				yym485 := z.DecBinary()
				_ = yym485
				if false {
				} else if z.HasExtensions() && z.DecExt(x.Selector) {
				} else {
					z.DecFallback(x.Selector, false)
				}
			}
		case "template":
			if r.TryDecodeAsNil() {
				x.Template = pkg2_api.PodTemplateSpec{}
			} else {
				yyv486 := &x.Template
				yyv486.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys483)
		} // end switch yys483
	} // end for yyj483
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *DaemonSetSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj487 int
	var yyb487 bool
	var yyhl487 bool = l >= 0
	yyj487++
	if yyhl487 {
		yyb487 = yyj487 > l
	} else {
		yyb487 = r.CheckBreak()
	}
	if yyb487 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		if x.Selector != nil {
			x.Selector = nil
		}
	} else {
		if x.Selector == nil {
			x.Selector = new(pkg1_unversioned.LabelSelector)
		}
		yym489 := z.DecBinary()
		_ = yym489
		if false {
		} else if z.HasExtensions() && z.DecExt(x.Selector) {
		} else {
			z.DecFallback(x.Selector, false)
		}
	}
	yyj487++
	if yyhl487 {
		yyb487 = yyj487 > l
	} else {
		yyb487 = r.CheckBreak()
	}
	if yyb487 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Template = pkg2_api.PodTemplateSpec{}
	} else {
		yyv490 := &x.Template
		yyv490.CodecDecodeSelf(d)
	}
	for {
		yyj487++
		if yyhl487 {
			yyb487 = yyj487 > l
		} else {
			yyb487 = r.CheckBreak()
		}
		if yyb487 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj487-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *DaemonSetStatus) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym491 := z.EncBinary()
		_ = yym491
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep492 := !z.EncBinary()
			yy2arr492 := z.EncBasicHandle().StructToArray
			var yyq492 [3]bool
			_, _, _ = yysep492, yyq492, yy2arr492
			const yyr492 bool = false
			var yynn492 int
			if yyr492 || yy2arr492 {
				r.EncodeArrayStart(3)
			} else {
				yynn492 = 3
				for _, b := range yyq492 {
					if b {
						yynn492++
					}
				}
				r.EncodeMapStart(yynn492)
				yynn492 = 0
			}
			if yyr492 || yy2arr492 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym494 := z.EncBinary()
				_ = yym494
				if false {
				} else {
					r.EncodeInt(int64(x.CurrentNumberScheduled))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("currentNumberScheduled"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yym495 := z.EncBinary()
				_ = yym495
				if false {
				} else {
					r.EncodeInt(int64(x.CurrentNumberScheduled))
				}
			}
			if yyr492 || yy2arr492 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym497 := z.EncBinary()
				_ = yym497
				if false {
				} else {
					r.EncodeInt(int64(x.NumberMisscheduled))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("numberMisscheduled"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yym498 := z.EncBinary()
				_ = yym498
				if false {
				} else {
					r.EncodeInt(int64(x.NumberMisscheduled))
				}
			}
			if yyr492 || yy2arr492 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym500 := z.EncBinary()
				_ = yym500
				if false {
				} else {
					r.EncodeInt(int64(x.DesiredNumberScheduled))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("desiredNumberScheduled"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yym501 := z.EncBinary()
				_ = yym501
				if false {
				} else {
					r.EncodeInt(int64(x.DesiredNumberScheduled))
				}
			}
			if yyr492 || yy2arr492 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *DaemonSetStatus) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym502 := z.DecBinary()
	_ = yym502
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct503 := r.ContainerType()
		if yyct503 == codecSelferValueTypeMap1234 {
			yyl503 := r.ReadMapStart()
			if yyl503 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl503, d)
			}
		} else if yyct503 == codecSelferValueTypeArray1234 {
			yyl503 := r.ReadArrayStart()
			if yyl503 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl503, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *DaemonSetStatus) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys504Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys504Slc
	var yyhl504 bool = l >= 0
	for yyj504 := 0; ; yyj504++ {
		if yyhl504 {
			if yyj504 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys504Slc = r.DecodeBytes(yys504Slc, true, true)
		yys504 := string(yys504Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys504 {
		case "currentNumberScheduled":
			if r.TryDecodeAsNil() {
				x.CurrentNumberScheduled = 0
			} else {
				x.CurrentNumberScheduled = int32(r.DecodeInt(32))
			}
		case "numberMisscheduled":
			if r.TryDecodeAsNil() {
				x.NumberMisscheduled = 0
			} else {
				x.NumberMisscheduled = int32(r.DecodeInt(32))
			}
		case "desiredNumberScheduled":
			if r.TryDecodeAsNil() {
				x.DesiredNumberScheduled = 0
			} else {
				x.DesiredNumberScheduled = int32(r.DecodeInt(32))
			}
		default:
			z.DecStructFieldNotFound(-1, yys504)
		} // end switch yys504
	} // end for yyj504
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *DaemonSetStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj508 int
	var yyb508 bool
	var yyhl508 bool = l >= 0
	yyj508++
	if yyhl508 {
		yyb508 = yyj508 > l
	} else {
		yyb508 = r.CheckBreak()
	}
	if yyb508 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.CurrentNumberScheduled = 0
	} else {
		x.CurrentNumberScheduled = int32(r.DecodeInt(32))
	}
	yyj508++
	if yyhl508 {
		yyb508 = yyj508 > l
	} else {
		yyb508 = r.CheckBreak()
	}
	if yyb508 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.NumberMisscheduled = 0
	} else {
		x.NumberMisscheduled = int32(r.DecodeInt(32))
	}
	yyj508++
	if yyhl508 {
		yyb508 = yyj508 > l
	} else {
		yyb508 = r.CheckBreak()
	}
	if yyb508 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.DesiredNumberScheduled = 0
	} else {
		x.DesiredNumberScheduled = int32(r.DecodeInt(32))
	}
	for {
		yyj508++
		if yyhl508 {
			yyb508 = yyj508 > l
		} else {
			yyb508 = r.CheckBreak()
		}
		if yyb508 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj508-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *DaemonSet) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym512 := z.EncBinary()
		_ = yym512
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep513 := !z.EncBinary()
			yy2arr513 := z.EncBasicHandle().StructToArray
			var yyq513 [5]bool
			_, _, _ = yysep513, yyq513, yy2arr513
			const yyr513 bool = false
			yyq513[0] = x.Kind != ""
			yyq513[1] = x.APIVersion != ""
			yyq513[2] = true
			yyq513[3] = true
			yyq513[4] = true
			var yynn513 int
			if yyr513 || yy2arr513 {
				r.EncodeArrayStart(5)
			} else {
				yynn513 = 0
				for _, b := range yyq513 {
					if b {
						yynn513++
					}
				}
				r.EncodeMapStart(yynn513)
				yynn513 = 0
			}
			if yyr513 || yy2arr513 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq513[0] {
					yym515 := z.EncBinary()
					_ = yym515
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq513[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym516 := z.EncBinary()
					_ = yym516
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr513 || yy2arr513 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq513[1] {
					yym518 := z.EncBinary()
					_ = yym518
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq513[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym519 := z.EncBinary()
					_ = yym519
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr513 || yy2arr513 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq513[2] {
					yy521 := &x.ObjectMeta
					yy521.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq513[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy522 := &x.ObjectMeta
					yy522.CodecEncodeSelf(e)
				}
			}
			if yyr513 || yy2arr513 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq513[3] {
					yy524 := &x.Spec
					yy524.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq513[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("spec"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy525 := &x.Spec
					yy525.CodecEncodeSelf(e)
				}
			}
			if yyr513 || yy2arr513 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq513[4] {
					yy527 := &x.Status
					yy527.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq513[4] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("status"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy528 := &x.Status
					yy528.CodecEncodeSelf(e)
				}
			}
			if yyr513 || yy2arr513 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *DaemonSet) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym529 := z.DecBinary()
	_ = yym529
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct530 := r.ContainerType()
		if yyct530 == codecSelferValueTypeMap1234 {
			yyl530 := r.ReadMapStart()
			if yyl530 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl530, d)
			}
		} else if yyct530 == codecSelferValueTypeArray1234 {
			yyl530 := r.ReadArrayStart()
			if yyl530 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl530, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *DaemonSet) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys531Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys531Slc
	var yyhl531 bool = l >= 0
	for yyj531 := 0; ; yyj531++ {
		if yyhl531 {
			if yyj531 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys531Slc = r.DecodeBytes(yys531Slc, true, true)
		yys531 := string(yys531Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys531 {
		case "kind":
			if r.TryDecodeAsNil() {
				x.Kind = ""
			} else {
				x.Kind = string(r.DecodeString())
			}
		case "apiVersion":
			if r.TryDecodeAsNil() {
				x.APIVersion = ""
			} else {
				x.APIVersion = string(r.DecodeString())
			}
		case "metadata":
			if r.TryDecodeAsNil() {
				x.ObjectMeta = pkg2_api.ObjectMeta{}
			} else {
				yyv534 := &x.ObjectMeta
				yyv534.CodecDecodeSelf(d)
			}
		case "spec":
			if r.TryDecodeAsNil() {
				x.Spec = DaemonSetSpec{}
			} else {
				yyv535 := &x.Spec
				yyv535.CodecDecodeSelf(d)
			}
		case "status":
			if r.TryDecodeAsNil() {
				x.Status = DaemonSetStatus{}
			} else {
				yyv536 := &x.Status
				yyv536.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys531)
		} // end switch yys531
	} // end for yyj531
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *DaemonSet) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj537 int
	var yyb537 bool
	var yyhl537 bool = l >= 0
	yyj537++
	if yyhl537 {
		yyb537 = yyj537 > l
	} else {
		yyb537 = r.CheckBreak()
	}
	if yyb537 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj537++
	if yyhl537 {
		yyb537 = yyj537 > l
	} else {
		yyb537 = r.CheckBreak()
	}
	if yyb537 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj537++
	if yyhl537 {
		yyb537 = yyj537 > l
	} else {
		yyb537 = r.CheckBreak()
	}
	if yyb537 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ObjectMeta = pkg2_api.ObjectMeta{}
	} else {
		yyv540 := &x.ObjectMeta
		yyv540.CodecDecodeSelf(d)
	}
	yyj537++
	if yyhl537 {
		yyb537 = yyj537 > l
	} else {
		yyb537 = r.CheckBreak()
	}
	if yyb537 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Spec = DaemonSetSpec{}
	} else {
		yyv541 := &x.Spec
		yyv541.CodecDecodeSelf(d)
	}
	yyj537++
	if yyhl537 {
		yyb537 = yyj537 > l
	} else {
		yyb537 = r.CheckBreak()
	}
	if yyb537 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Status = DaemonSetStatus{}
	} else {
		yyv542 := &x.Status
		yyv542.CodecDecodeSelf(d)
	}
	for {
		yyj537++
		if yyhl537 {
			yyb537 = yyj537 > l
		} else {
			yyb537 = r.CheckBreak()
		}
		if yyb537 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj537-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *DaemonSetList) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym543 := z.EncBinary()
		_ = yym543
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep544 := !z.EncBinary()
			yy2arr544 := z.EncBasicHandle().StructToArray
			var yyq544 [4]bool
			_, _, _ = yysep544, yyq544, yy2arr544
			const yyr544 bool = false
			yyq544[0] = x.Kind != ""
			yyq544[1] = x.APIVersion != ""
			yyq544[2] = true
			var yynn544 int
			if yyr544 || yy2arr544 {
				r.EncodeArrayStart(4)
			} else {
				yynn544 = 1
				for _, b := range yyq544 {
					if b {
						yynn544++
					}
				}
				r.EncodeMapStart(yynn544)
				yynn544 = 0
			}
			if yyr544 || yy2arr544 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq544[0] {
					yym546 := z.EncBinary()
					_ = yym546
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq544[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym547 := z.EncBinary()
					_ = yym547
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr544 || yy2arr544 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq544[1] {
					yym549 := z.EncBinary()
					_ = yym549
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq544[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym550 := z.EncBinary()
					_ = yym550
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr544 || yy2arr544 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq544[2] {
					yy552 := &x.ListMeta
					yym553 := z.EncBinary()
					_ = yym553
					if false {
					} else if z.HasExtensions() && z.EncExt(yy552) {
					} else {
						z.EncFallback(yy552)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq544[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy554 := &x.ListMeta
					yym555 := z.EncBinary()
					_ = yym555
					if false {
					} else if z.HasExtensions() && z.EncExt(yy554) {
					} else {
						z.EncFallback(yy554)
					}
				}
			}
			if yyr544 || yy2arr544 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym557 := z.EncBinary()
					_ = yym557
					if false {
					} else {
						h.encSliceDaemonSet(([]DaemonSet)(x.Items), e)
					}
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("items"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym558 := z.EncBinary()
					_ = yym558
					if false {
					} else {
						h.encSliceDaemonSet(([]DaemonSet)(x.Items), e)
					}
				}
			}
			if yyr544 || yy2arr544 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *DaemonSetList) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym559 := z.DecBinary()
	_ = yym559
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct560 := r.ContainerType()
		if yyct560 == codecSelferValueTypeMap1234 {
			yyl560 := r.ReadMapStart()
			if yyl560 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl560, d)
			}
		} else if yyct560 == codecSelferValueTypeArray1234 {
			yyl560 := r.ReadArrayStart()
			if yyl560 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl560, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *DaemonSetList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys561Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys561Slc
	var yyhl561 bool = l >= 0
	for yyj561 := 0; ; yyj561++ {
		if yyhl561 {
			if yyj561 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys561Slc = r.DecodeBytes(yys561Slc, true, true)
		yys561 := string(yys561Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys561 {
		case "kind":
			if r.TryDecodeAsNil() {
				x.Kind = ""
			} else {
				x.Kind = string(r.DecodeString())
			}
		case "apiVersion":
			if r.TryDecodeAsNil() {
				x.APIVersion = ""
			} else {
				x.APIVersion = string(r.DecodeString())
			}
		case "metadata":
			if r.TryDecodeAsNil() {
				x.ListMeta = pkg1_unversioned.ListMeta{}
			} else {
				yyv564 := &x.ListMeta
				yym565 := z.DecBinary()
				_ = yym565
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv564) {
				} else {
					z.DecFallback(yyv564, false)
				}
			}
		case "items":
			if r.TryDecodeAsNil() {
				x.Items = nil
			} else {
				yyv566 := &x.Items
				yym567 := z.DecBinary()
				_ = yym567
				if false {
				} else {
					h.decSliceDaemonSet((*[]DaemonSet)(yyv566), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys561)
		} // end switch yys561
	} // end for yyj561
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *DaemonSetList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj568 int
	var yyb568 bool
	var yyhl568 bool = l >= 0
	yyj568++
	if yyhl568 {
		yyb568 = yyj568 > l
	} else {
		yyb568 = r.CheckBreak()
	}
	if yyb568 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj568++
	if yyhl568 {
		yyb568 = yyj568 > l
	} else {
		yyb568 = r.CheckBreak()
	}
	if yyb568 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj568++
	if yyhl568 {
		yyb568 = yyj568 > l
	} else {
		yyb568 = r.CheckBreak()
	}
	if yyb568 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ListMeta = pkg1_unversioned.ListMeta{}
	} else {
		yyv571 := &x.ListMeta
		yym572 := z.DecBinary()
		_ = yym572
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv571) {
		} else {
			z.DecFallback(yyv571, false)
		}
	}
	yyj568++
	if yyhl568 {
		yyb568 = yyj568 > l
	} else {
		yyb568 = r.CheckBreak()
	}
	if yyb568 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Items = nil
	} else {
		yyv573 := &x.Items
		yym574 := z.DecBinary()
		_ = yym574
		if false {
		} else {
			h.decSliceDaemonSet((*[]DaemonSet)(yyv573), d)
		}
	}
	for {
		yyj568++
		if yyhl568 {
			yyb568 = yyj568 > l
		} else {
			yyb568 = r.CheckBreak()
		}
		if yyb568 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj568-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *ThirdPartyResourceDataList) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym575 := z.EncBinary()
		_ = yym575
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep576 := !z.EncBinary()
			yy2arr576 := z.EncBasicHandle().StructToArray
			var yyq576 [4]bool
			_, _, _ = yysep576, yyq576, yy2arr576
			const yyr576 bool = false
			yyq576[0] = x.Kind != ""
			yyq576[1] = x.APIVersion != ""
			yyq576[2] = true
			var yynn576 int
			if yyr576 || yy2arr576 {
				r.EncodeArrayStart(4)
			} else {
				yynn576 = 1
				for _, b := range yyq576 {
					if b {
						yynn576++
					}
				}
				r.EncodeMapStart(yynn576)
				yynn576 = 0
			}
			if yyr576 || yy2arr576 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq576[0] {
					yym578 := z.EncBinary()
					_ = yym578
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq576[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym579 := z.EncBinary()
					_ = yym579
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr576 || yy2arr576 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq576[1] {
					yym581 := z.EncBinary()
					_ = yym581
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq576[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym582 := z.EncBinary()
					_ = yym582
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr576 || yy2arr576 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq576[2] {
					yy584 := &x.ListMeta
					yym585 := z.EncBinary()
					_ = yym585
					if false {
					} else if z.HasExtensions() && z.EncExt(yy584) {
					} else {
						z.EncFallback(yy584)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq576[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy586 := &x.ListMeta
					yym587 := z.EncBinary()
					_ = yym587
					if false {
					} else if z.HasExtensions() && z.EncExt(yy586) {
					} else {
						z.EncFallback(yy586)
					}
				}
			}
			if yyr576 || yy2arr576 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym589 := z.EncBinary()
					_ = yym589
					if false {
					} else {
						h.encSliceThirdPartyResourceData(([]ThirdPartyResourceData)(x.Items), e)
					}
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("items"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym590 := z.EncBinary()
					_ = yym590
					if false {
					} else {
						h.encSliceThirdPartyResourceData(([]ThirdPartyResourceData)(x.Items), e)
					}
				}
			}
			if yyr576 || yy2arr576 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *ThirdPartyResourceDataList) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym591 := z.DecBinary()
	_ = yym591
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct592 := r.ContainerType()
		if yyct592 == codecSelferValueTypeMap1234 {
			yyl592 := r.ReadMapStart()
			if yyl592 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl592, d)
			}
		} else if yyct592 == codecSelferValueTypeArray1234 {
			yyl592 := r.ReadArrayStart()
			if yyl592 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl592, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *ThirdPartyResourceDataList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys593Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys593Slc
	var yyhl593 bool = l >= 0
	for yyj593 := 0; ; yyj593++ {
		if yyhl593 {
			if yyj593 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys593Slc = r.DecodeBytes(yys593Slc, true, true)
		yys593 := string(yys593Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys593 {
		case "kind":
			if r.TryDecodeAsNil() {
				x.Kind = ""
			} else {
				x.Kind = string(r.DecodeString())
			}
		case "apiVersion":
			if r.TryDecodeAsNil() {
				x.APIVersion = ""
			} else {
				x.APIVersion = string(r.DecodeString())
			}
		case "metadata":
			if r.TryDecodeAsNil() {
				x.ListMeta = pkg1_unversioned.ListMeta{}
			} else {
				yyv596 := &x.ListMeta
				yym597 := z.DecBinary()
				_ = yym597
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv596) {
				} else {
					z.DecFallback(yyv596, false)
				}
			}
		case "items":
			if r.TryDecodeAsNil() {
				x.Items = nil
			} else {
				yyv598 := &x.Items
				yym599 := z.DecBinary()
				_ = yym599
				if false {
				} else {
					h.decSliceThirdPartyResourceData((*[]ThirdPartyResourceData)(yyv598), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys593)
		} // end switch yys593
	} // end for yyj593
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *ThirdPartyResourceDataList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj600 int
	var yyb600 bool
	var yyhl600 bool = l >= 0
	yyj600++
	if yyhl600 {
		yyb600 = yyj600 > l
	} else {
		yyb600 = r.CheckBreak()
	}
	if yyb600 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj600++
	if yyhl600 {
		yyb600 = yyj600 > l
	} else {
		yyb600 = r.CheckBreak()
	}
	if yyb600 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj600++
	if yyhl600 {
		yyb600 = yyj600 > l
	} else {
		yyb600 = r.CheckBreak()
	}
	if yyb600 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ListMeta = pkg1_unversioned.ListMeta{}
	} else {
		yyv603 := &x.ListMeta
		yym604 := z.DecBinary()
		_ = yym604
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv603) {
		} else {
			z.DecFallback(yyv603, false)
		}
	}
	yyj600++
	if yyhl600 {
		yyb600 = yyj600 > l
	} else {
		yyb600 = r.CheckBreak()
	}
	if yyb600 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Items = nil
	} else {
		yyv605 := &x.Items
		yym606 := z.DecBinary()
		_ = yym606
		if false {
		} else {
			h.decSliceThirdPartyResourceData((*[]ThirdPartyResourceData)(yyv605), d)
		}
	}
	for {
		yyj600++
		if yyhl600 {
			yyb600 = yyj600 > l
		} else {
			yyb600 = r.CheckBreak()
		}
		if yyb600 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj600-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *Ingress) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym607 := z.EncBinary()
		_ = yym607
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep608 := !z.EncBinary()
			yy2arr608 := z.EncBasicHandle().StructToArray
			var yyq608 [5]bool
			_, _, _ = yysep608, yyq608, yy2arr608
			const yyr608 bool = false
			yyq608[0] = x.Kind != ""
			yyq608[1] = x.APIVersion != ""
			yyq608[2] = true
			yyq608[3] = true
			yyq608[4] = true
			var yynn608 int
			if yyr608 || yy2arr608 {
				r.EncodeArrayStart(5)
			} else {
				yynn608 = 0
				for _, b := range yyq608 {
					if b {
						yynn608++
					}
				}
				r.EncodeMapStart(yynn608)
				yynn608 = 0
			}
			if yyr608 || yy2arr608 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq608[0] {
					yym610 := z.EncBinary()
					_ = yym610
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq608[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym611 := z.EncBinary()
					_ = yym611
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr608 || yy2arr608 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq608[1] {
					yym613 := z.EncBinary()
					_ = yym613
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq608[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym614 := z.EncBinary()
					_ = yym614
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr608 || yy2arr608 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq608[2] {
					yy616 := &x.ObjectMeta
					yy616.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq608[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy617 := &x.ObjectMeta
					yy617.CodecEncodeSelf(e)
				}
			}
			if yyr608 || yy2arr608 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq608[3] {
					yy619 := &x.Spec
					yy619.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq608[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("spec"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy620 := &x.Spec
					yy620.CodecEncodeSelf(e)
				}
			}
			if yyr608 || yy2arr608 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq608[4] {
					yy622 := &x.Status
					yy622.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq608[4] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("status"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy623 := &x.Status
					yy623.CodecEncodeSelf(e)
				}
			}
			if yyr608 || yy2arr608 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *Ingress) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym624 := z.DecBinary()
	_ = yym624
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct625 := r.ContainerType()
		if yyct625 == codecSelferValueTypeMap1234 {
			yyl625 := r.ReadMapStart()
			if yyl625 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl625, d)
			}
		} else if yyct625 == codecSelferValueTypeArray1234 {
			yyl625 := r.ReadArrayStart()
			if yyl625 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl625, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *Ingress) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys626Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys626Slc
	var yyhl626 bool = l >= 0
	for yyj626 := 0; ; yyj626++ {
		if yyhl626 {
			if yyj626 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys626Slc = r.DecodeBytes(yys626Slc, true, true)
		yys626 := string(yys626Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys626 {
		case "kind":
			if r.TryDecodeAsNil() {
				x.Kind = ""
			} else {
				x.Kind = string(r.DecodeString())
			}
		case "apiVersion":
			if r.TryDecodeAsNil() {
				x.APIVersion = ""
			} else {
				x.APIVersion = string(r.DecodeString())
			}
		case "metadata":
			if r.TryDecodeAsNil() {
				x.ObjectMeta = pkg2_api.ObjectMeta{}
			} else {
				yyv629 := &x.ObjectMeta
				yyv629.CodecDecodeSelf(d)
			}
		case "spec":
			if r.TryDecodeAsNil() {
				x.Spec = IngressSpec{}
			} else {
				yyv630 := &x.Spec
				yyv630.CodecDecodeSelf(d)
			}
		case "status":
			if r.TryDecodeAsNil() {
				x.Status = IngressStatus{}
			} else {
				yyv631 := &x.Status
				yyv631.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys626)
		} // end switch yys626
	} // end for yyj626
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *Ingress) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj632 int
	var yyb632 bool
	var yyhl632 bool = l >= 0
	yyj632++
	if yyhl632 {
		yyb632 = yyj632 > l
	} else {
		yyb632 = r.CheckBreak()
	}
	if yyb632 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj632++
	if yyhl632 {
		yyb632 = yyj632 > l
	} else {
		yyb632 = r.CheckBreak()
	}
	if yyb632 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj632++
	if yyhl632 {
		yyb632 = yyj632 > l
	} else {
		yyb632 = r.CheckBreak()
	}
	if yyb632 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ObjectMeta = pkg2_api.ObjectMeta{}
	} else {
		yyv635 := &x.ObjectMeta
		yyv635.CodecDecodeSelf(d)
	}
	yyj632++
	if yyhl632 {
		yyb632 = yyj632 > l
	} else {
		yyb632 = r.CheckBreak()
	}
	if yyb632 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Spec = IngressSpec{}
	} else {
		yyv636 := &x.Spec
		yyv636.CodecDecodeSelf(d)
	}
	yyj632++
	if yyhl632 {
		yyb632 = yyj632 > l
	} else {
		yyb632 = r.CheckBreak()
	}
	if yyb632 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Status = IngressStatus{}
	} else {
		yyv637 := &x.Status
		yyv637.CodecDecodeSelf(d)
	}
	for {
		yyj632++
		if yyhl632 {
			yyb632 = yyj632 > l
		} else {
			yyb632 = r.CheckBreak()
		}
		if yyb632 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj632-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *IngressList) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym638 := z.EncBinary()
		_ = yym638
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep639 := !z.EncBinary()
			yy2arr639 := z.EncBasicHandle().StructToArray
			var yyq639 [4]bool
			_, _, _ = yysep639, yyq639, yy2arr639
			const yyr639 bool = false
			yyq639[0] = x.Kind != ""
			yyq639[1] = x.APIVersion != ""
			yyq639[2] = true
			var yynn639 int
			if yyr639 || yy2arr639 {
				r.EncodeArrayStart(4)
			} else {
				yynn639 = 1
				for _, b := range yyq639 {
					if b {
						yynn639++
					}
				}
				r.EncodeMapStart(yynn639)
				yynn639 = 0
			}
			if yyr639 || yy2arr639 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq639[0] {
					yym641 := z.EncBinary()
					_ = yym641
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq639[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym642 := z.EncBinary()
					_ = yym642
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr639 || yy2arr639 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq639[1] {
					yym644 := z.EncBinary()
					_ = yym644
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq639[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym645 := z.EncBinary()
					_ = yym645
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr639 || yy2arr639 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq639[2] {
					yy647 := &x.ListMeta
					yym648 := z.EncBinary()
					_ = yym648
					if false {
					} else if z.HasExtensions() && z.EncExt(yy647) {
					} else {
						z.EncFallback(yy647)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq639[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy649 := &x.ListMeta
					yym650 := z.EncBinary()
					_ = yym650
					if false {
					} else if z.HasExtensions() && z.EncExt(yy649) {
					} else {
						z.EncFallback(yy649)
					}
				}
			}
			if yyr639 || yy2arr639 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym652 := z.EncBinary()
					_ = yym652
					if false {
					} else {
						h.encSliceIngress(([]Ingress)(x.Items), e)
					}
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("items"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym653 := z.EncBinary()
					_ = yym653
					if false {
					} else {
						h.encSliceIngress(([]Ingress)(x.Items), e)
					}
				}
			}
			if yyr639 || yy2arr639 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *IngressList) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym654 := z.DecBinary()
	_ = yym654
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct655 := r.ContainerType()
		if yyct655 == codecSelferValueTypeMap1234 {
			yyl655 := r.ReadMapStart()
			if yyl655 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl655, d)
			}
		} else if yyct655 == codecSelferValueTypeArray1234 {
			yyl655 := r.ReadArrayStart()
			if yyl655 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl655, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *IngressList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys656Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys656Slc
	var yyhl656 bool = l >= 0
	for yyj656 := 0; ; yyj656++ {
		if yyhl656 {
			if yyj656 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys656Slc = r.DecodeBytes(yys656Slc, true, true)
		yys656 := string(yys656Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys656 {
		case "kind":
			if r.TryDecodeAsNil() {
				x.Kind = ""
			} else {
				x.Kind = string(r.DecodeString())
			}
		case "apiVersion":
			if r.TryDecodeAsNil() {
				x.APIVersion = ""
			} else {
				x.APIVersion = string(r.DecodeString())
			}
		case "metadata":
			if r.TryDecodeAsNil() {
				x.ListMeta = pkg1_unversioned.ListMeta{}
			} else {
				yyv659 := &x.ListMeta
				yym660 := z.DecBinary()
				_ = yym660
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv659) {
				} else {
					z.DecFallback(yyv659, false)
				}
			}
		case "items":
			if r.TryDecodeAsNil() {
				x.Items = nil
			} else {
				yyv661 := &x.Items
				yym662 := z.DecBinary()
				_ = yym662
				if false {
				} else {
					h.decSliceIngress((*[]Ingress)(yyv661), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys656)
		} // end switch yys656
	} // end for yyj656
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *IngressList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj663 int
	var yyb663 bool
	var yyhl663 bool = l >= 0
	yyj663++
	if yyhl663 {
		yyb663 = yyj663 > l
	} else {
		yyb663 = r.CheckBreak()
	}
	if yyb663 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj663++
	if yyhl663 {
		yyb663 = yyj663 > l
	} else {
		yyb663 = r.CheckBreak()
	}
	if yyb663 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj663++
	if yyhl663 {
		yyb663 = yyj663 > l
	} else {
		yyb663 = r.CheckBreak()
	}
	if yyb663 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ListMeta = pkg1_unversioned.ListMeta{}
	} else {
		yyv666 := &x.ListMeta
		yym667 := z.DecBinary()
		_ = yym667
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv666) {
		} else {
			z.DecFallback(yyv666, false)
		}
	}
	yyj663++
	if yyhl663 {
		yyb663 = yyj663 > l
	} else {
		yyb663 = r.CheckBreak()
	}
	if yyb663 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Items = nil
	} else {
		yyv668 := &x.Items
		yym669 := z.DecBinary()
		_ = yym669
		if false {
		} else {
			h.decSliceIngress((*[]Ingress)(yyv668), d)
		}
	}
	for {
		yyj663++
		if yyhl663 {
			yyb663 = yyj663 > l
		} else {
			yyb663 = r.CheckBreak()
		}
		if yyb663 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj663-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *IngressSpec) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym670 := z.EncBinary()
		_ = yym670
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep671 := !z.EncBinary()
			yy2arr671 := z.EncBasicHandle().StructToArray
			var yyq671 [3]bool
			_, _, _ = yysep671, yyq671, yy2arr671
			const yyr671 bool = false
			yyq671[0] = x.Backend != nil
			yyq671[1] = len(x.TLS) != 0
			yyq671[2] = len(x.Rules) != 0
			var yynn671 int
			if yyr671 || yy2arr671 {
				r.EncodeArrayStart(3)
			} else {
				yynn671 = 0
				for _, b := range yyq671 {
					if b {
						yynn671++
					}
				}
				r.EncodeMapStart(yynn671)
				yynn671 = 0
			}
			if yyr671 || yy2arr671 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq671[0] {
					if x.Backend == nil {
						r.EncodeNil()
					} else {
						x.Backend.CodecEncodeSelf(e)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq671[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("backend"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.Backend == nil {
						r.EncodeNil()
					} else {
						x.Backend.CodecEncodeSelf(e)
					}
				}
			}
			if yyr671 || yy2arr671 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq671[1] {
					if x.TLS == nil {
						r.EncodeNil()
					} else {
						yym674 := z.EncBinary()
						_ = yym674
						if false {
						} else {
							h.encSliceIngressTLS(([]IngressTLS)(x.TLS), e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq671[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("tls"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.TLS == nil {
						r.EncodeNil()
					} else {
						yym675 := z.EncBinary()
						_ = yym675
						if false {
						} else {
							h.encSliceIngressTLS(([]IngressTLS)(x.TLS), e)
						}
					}
				}
			}
			if yyr671 || yy2arr671 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq671[2] {
					if x.Rules == nil {
						r.EncodeNil()
					} else {
						yym677 := z.EncBinary()
						_ = yym677
						if false {
						} else {
							h.encSliceIngressRule(([]IngressRule)(x.Rules), e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq671[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("rules"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.Rules == nil {
						r.EncodeNil()
					} else {
						yym678 := z.EncBinary()
						_ = yym678
						if false {
						} else {
							h.encSliceIngressRule(([]IngressRule)(x.Rules), e)
						}
					}
				}
			}
			if yyr671 || yy2arr671 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *IngressSpec) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym679 := z.DecBinary()
	_ = yym679
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct680 := r.ContainerType()
		if yyct680 == codecSelferValueTypeMap1234 {
			yyl680 := r.ReadMapStart()
			if yyl680 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl680, d)
			}
		} else if yyct680 == codecSelferValueTypeArray1234 {
			yyl680 := r.ReadArrayStart()
			if yyl680 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl680, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *IngressSpec) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys681Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys681Slc
	var yyhl681 bool = l >= 0
	for yyj681 := 0; ; yyj681++ {
		if yyhl681 {
			if yyj681 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys681Slc = r.DecodeBytes(yys681Slc, true, true)
		yys681 := string(yys681Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys681 {
		case "backend":
			if r.TryDecodeAsNil() {
				if x.Backend != nil {
					x.Backend = nil
				}
			} else {
				if x.Backend == nil {
					x.Backend = new(IngressBackend)
				}
				x.Backend.CodecDecodeSelf(d)
			}
		case "tls":
			if r.TryDecodeAsNil() {
				x.TLS = nil
			} else {
				yyv683 := &x.TLS
				yym684 := z.DecBinary()
				_ = yym684
				if false {
				} else {
					h.decSliceIngressTLS((*[]IngressTLS)(yyv683), d)
				}
			}
		case "rules":
			if r.TryDecodeAsNil() {
				x.Rules = nil
			} else {
				yyv685 := &x.Rules
				yym686 := z.DecBinary()
				_ = yym686
				if false {
				} else {
					h.decSliceIngressRule((*[]IngressRule)(yyv685), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys681)
		} // end switch yys681
	} // end for yyj681
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *IngressSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj687 int
	var yyb687 bool
	var yyhl687 bool = l >= 0
	yyj687++
	if yyhl687 {
		yyb687 = yyj687 > l
	} else {
		yyb687 = r.CheckBreak()
	}
	if yyb687 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		if x.Backend != nil {
			x.Backend = nil
		}
	} else {
		if x.Backend == nil {
			x.Backend = new(IngressBackend)
		}
		x.Backend.CodecDecodeSelf(d)
	}
	yyj687++
	if yyhl687 {
		yyb687 = yyj687 > l
	} else {
		yyb687 = r.CheckBreak()
	}
	if yyb687 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.TLS = nil
	} else {
		yyv689 := &x.TLS
		yym690 := z.DecBinary()
		_ = yym690
		if false {
		} else {
			h.decSliceIngressTLS((*[]IngressTLS)(yyv689), d)
		}
	}
	yyj687++
	if yyhl687 {
		yyb687 = yyj687 > l
	} else {
		yyb687 = r.CheckBreak()
	}
	if yyb687 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Rules = nil
	} else {
		yyv691 := &x.Rules
		yym692 := z.DecBinary()
		_ = yym692
		if false {
		} else {
			h.decSliceIngressRule((*[]IngressRule)(yyv691), d)
		}
	}
	for {
		yyj687++
		if yyhl687 {
			yyb687 = yyj687 > l
		} else {
			yyb687 = r.CheckBreak()
		}
		if yyb687 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj687-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *IngressTLS) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym693 := z.EncBinary()
		_ = yym693
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep694 := !z.EncBinary()
			yy2arr694 := z.EncBasicHandle().StructToArray
			var yyq694 [2]bool
			_, _, _ = yysep694, yyq694, yy2arr694
			const yyr694 bool = false
			yyq694[0] = len(x.Hosts) != 0
			yyq694[1] = x.SecretName != ""
			var yynn694 int
			if yyr694 || yy2arr694 {
				r.EncodeArrayStart(2)
			} else {
				yynn694 = 0
				for _, b := range yyq694 {
					if b {
						yynn694++
					}
				}
				r.EncodeMapStart(yynn694)
				yynn694 = 0
			}
			if yyr694 || yy2arr694 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq694[0] {
					if x.Hosts == nil {
						r.EncodeNil()
					} else {
						yym696 := z.EncBinary()
						_ = yym696
						if false {
						} else {
							z.F.EncSliceStringV(x.Hosts, false, e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq694[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("hosts"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.Hosts == nil {
						r.EncodeNil()
					} else {
						yym697 := z.EncBinary()
						_ = yym697
						if false {
						} else {
							z.F.EncSliceStringV(x.Hosts, false, e)
						}
					}
				}
			}
			if yyr694 || yy2arr694 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq694[1] {
					yym699 := z.EncBinary()
					_ = yym699
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.SecretName))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq694[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("secretName"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym700 := z.EncBinary()
					_ = yym700
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.SecretName))
					}
				}
			}
			if yyr694 || yy2arr694 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *IngressTLS) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym701 := z.DecBinary()
	_ = yym701
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct702 := r.ContainerType()
		if yyct702 == codecSelferValueTypeMap1234 {
			yyl702 := r.ReadMapStart()
			if yyl702 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl702, d)
			}
		} else if yyct702 == codecSelferValueTypeArray1234 {
			yyl702 := r.ReadArrayStart()
			if yyl702 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl702, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *IngressTLS) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys703Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys703Slc
	var yyhl703 bool = l >= 0
	for yyj703 := 0; ; yyj703++ {
		if yyhl703 {
			if yyj703 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys703Slc = r.DecodeBytes(yys703Slc, true, true)
		yys703 := string(yys703Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys703 {
		case "hosts":
			if r.TryDecodeAsNil() {
				x.Hosts = nil
			} else {
				yyv704 := &x.Hosts
				yym705 := z.DecBinary()
				_ = yym705
				if false {
				} else {
					z.F.DecSliceStringX(yyv704, false, d)
				}
			}
		case "secretName":
			if r.TryDecodeAsNil() {
				x.SecretName = ""
			} else {
				x.SecretName = string(r.DecodeString())
			}
		default:
			z.DecStructFieldNotFound(-1, yys703)
		} // end switch yys703
	} // end for yyj703
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *IngressTLS) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj707 int
	var yyb707 bool
	var yyhl707 bool = l >= 0
	yyj707++
	if yyhl707 {
		yyb707 = yyj707 > l
	} else {
		yyb707 = r.CheckBreak()
	}
	if yyb707 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Hosts = nil
	} else {
		yyv708 := &x.Hosts
		yym709 := z.DecBinary()
		_ = yym709
		if false {
		} else {
			z.F.DecSliceStringX(yyv708, false, d)
		}
	}
	yyj707++
	if yyhl707 {
		yyb707 = yyj707 > l
	} else {
		yyb707 = r.CheckBreak()
	}
	if yyb707 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.SecretName = ""
	} else {
		x.SecretName = string(r.DecodeString())
	}
	for {
		yyj707++
		if yyhl707 {
			yyb707 = yyj707 > l
		} else {
			yyb707 = r.CheckBreak()
		}
		if yyb707 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj707-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *IngressStatus) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym711 := z.EncBinary()
		_ = yym711
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep712 := !z.EncBinary()
			yy2arr712 := z.EncBasicHandle().StructToArray
			var yyq712 [1]bool
			_, _, _ = yysep712, yyq712, yy2arr712
			const yyr712 bool = false
			yyq712[0] = true
			var yynn712 int
			if yyr712 || yy2arr712 {
				r.EncodeArrayStart(1)
			} else {
				yynn712 = 0
				for _, b := range yyq712 {
					if b {
						yynn712++
					}
				}
				r.EncodeMapStart(yynn712)
				yynn712 = 0
			}
			if yyr712 || yy2arr712 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq712[0] {
					yy714 := &x.LoadBalancer
					yy714.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq712[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("loadBalancer"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy715 := &x.LoadBalancer
					yy715.CodecEncodeSelf(e)
				}
			}
			if yyr712 || yy2arr712 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *IngressStatus) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym716 := z.DecBinary()
	_ = yym716
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct717 := r.ContainerType()
		if yyct717 == codecSelferValueTypeMap1234 {
			yyl717 := r.ReadMapStart()
			if yyl717 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl717, d)
			}
		} else if yyct717 == codecSelferValueTypeArray1234 {
			yyl717 := r.ReadArrayStart()
			if yyl717 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl717, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *IngressStatus) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys718Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys718Slc
	var yyhl718 bool = l >= 0
	for yyj718 := 0; ; yyj718++ {
		if yyhl718 {
			if yyj718 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys718Slc = r.DecodeBytes(yys718Slc, true, true)
		yys718 := string(yys718Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys718 {
		case "loadBalancer":
			if r.TryDecodeAsNil() {
				x.LoadBalancer = pkg2_api.LoadBalancerStatus{}
			} else {
				yyv719 := &x.LoadBalancer
				yyv719.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys718)
		} // end switch yys718
	} // end for yyj718
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *IngressStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj720 int
	var yyb720 bool
	var yyhl720 bool = l >= 0
	yyj720++
	if yyhl720 {
		yyb720 = yyj720 > l
	} else {
		yyb720 = r.CheckBreak()
	}
	if yyb720 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.LoadBalancer = pkg2_api.LoadBalancerStatus{}
	} else {
		yyv721 := &x.LoadBalancer
		yyv721.CodecDecodeSelf(d)
	}
	for {
		yyj720++
		if yyhl720 {
			yyb720 = yyj720 > l
		} else {
			yyb720 = r.CheckBreak()
		}
		if yyb720 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj720-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *IngressRule) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym722 := z.EncBinary()
		_ = yym722
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep723 := !z.EncBinary()
			yy2arr723 := z.EncBasicHandle().StructToArray
			var yyq723 [2]bool
			_, _, _ = yysep723, yyq723, yy2arr723
			const yyr723 bool = false
			yyq723[0] = x.Host != ""
			yyq723[1] = x.IngressRuleValue.HTTP != nil && x.HTTP != nil
			var yynn723 int
			if yyr723 || yy2arr723 {
				r.EncodeArrayStart(2)
			} else {
				yynn723 = 0
				for _, b := range yyq723 {
					if b {
						yynn723++
					}
				}
				r.EncodeMapStart(yynn723)
				yynn723 = 0
			}
			if yyr723 || yy2arr723 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq723[0] {
					yym725 := z.EncBinary()
					_ = yym725
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Host))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq723[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("host"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym726 := z.EncBinary()
					_ = yym726
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Host))
					}
				}
			}
			var yyn727 bool
			if x.IngressRuleValue.HTTP == nil {
				yyn727 = true
				goto LABEL727
			}
		LABEL727:
			if yyr723 || yy2arr723 {
				if yyn727 {
					r.EncodeNil()
				} else {
					z.EncSendContainerState(codecSelfer_containerArrayElem1234)
					if yyq723[1] {
						if x.HTTP == nil {
							r.EncodeNil()
						} else {
							x.HTTP.CodecEncodeSelf(e)
						}
					} else {
						r.EncodeNil()
					}
				}
			} else {
				if yyq723[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("http"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if yyn727 {
						r.EncodeNil()
					} else {
						if x.HTTP == nil {
							r.EncodeNil()
						} else {
							x.HTTP.CodecEncodeSelf(e)
						}
					}
				}
			}
			if yyr723 || yy2arr723 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *IngressRule) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym728 := z.DecBinary()
	_ = yym728
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct729 := r.ContainerType()
		if yyct729 == codecSelferValueTypeMap1234 {
			yyl729 := r.ReadMapStart()
			if yyl729 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl729, d)
			}
		} else if yyct729 == codecSelferValueTypeArray1234 {
			yyl729 := r.ReadArrayStart()
			if yyl729 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl729, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *IngressRule) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys730Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys730Slc
	var yyhl730 bool = l >= 0
	for yyj730 := 0; ; yyj730++ {
		if yyhl730 {
			if yyj730 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys730Slc = r.DecodeBytes(yys730Slc, true, true)
		yys730 := string(yys730Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys730 {
		case "host":
			if r.TryDecodeAsNil() {
				x.Host = ""
			} else {
				x.Host = string(r.DecodeString())
			}
		case "http":
			if x.IngressRuleValue.HTTP == nil {
				x.IngressRuleValue.HTTP = new(HTTPIngressRuleValue)
			}
			if r.TryDecodeAsNil() {
				if x.HTTP != nil {
					x.HTTP = nil
				}
			} else {
				if x.HTTP == nil {
					x.HTTP = new(HTTPIngressRuleValue)
				}
				x.HTTP.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys730)
		} // end switch yys730
	} // end for yyj730
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *IngressRule) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj733 int
	var yyb733 bool
	var yyhl733 bool = l >= 0
	yyj733++
	if yyhl733 {
		yyb733 = yyj733 > l
	} else {
		yyb733 = r.CheckBreak()
	}
	if yyb733 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Host = ""
	} else {
		x.Host = string(r.DecodeString())
	}
	if x.IngressRuleValue.HTTP == nil {
		x.IngressRuleValue.HTTP = new(HTTPIngressRuleValue)
	}
	yyj733++
	if yyhl733 {
		yyb733 = yyj733 > l
	} else {
		yyb733 = r.CheckBreak()
	}
	if yyb733 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		if x.HTTP != nil {
			x.HTTP = nil
		}
	} else {
		if x.HTTP == nil {
			x.HTTP = new(HTTPIngressRuleValue)
		}
		x.HTTP.CodecDecodeSelf(d)
	}
	for {
		yyj733++
		if yyhl733 {
			yyb733 = yyj733 > l
		} else {
			yyb733 = r.CheckBreak()
		}
		if yyb733 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj733-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *IngressRuleValue) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym736 := z.EncBinary()
		_ = yym736
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep737 := !z.EncBinary()
			yy2arr737 := z.EncBasicHandle().StructToArray
			var yyq737 [1]bool
			_, _, _ = yysep737, yyq737, yy2arr737
			const yyr737 bool = false
			yyq737[0] = x.HTTP != nil
			var yynn737 int
			if yyr737 || yy2arr737 {
				r.EncodeArrayStart(1)
			} else {
				yynn737 = 0
				for _, b := range yyq737 {
					if b {
						yynn737++
					}
				}
				r.EncodeMapStart(yynn737)
				yynn737 = 0
			}
			if yyr737 || yy2arr737 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq737[0] {
					if x.HTTP == nil {
						r.EncodeNil()
					} else {
						x.HTTP.CodecEncodeSelf(e)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq737[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("http"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.HTTP == nil {
						r.EncodeNil()
					} else {
						x.HTTP.CodecEncodeSelf(e)
					}
				}
			}
			if yyr737 || yy2arr737 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *IngressRuleValue) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym739 := z.DecBinary()
	_ = yym739
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct740 := r.ContainerType()
		if yyct740 == codecSelferValueTypeMap1234 {
			yyl740 := r.ReadMapStart()
			if yyl740 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl740, d)
			}
		} else if yyct740 == codecSelferValueTypeArray1234 {
			yyl740 := r.ReadArrayStart()
			if yyl740 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl740, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *IngressRuleValue) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys741Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys741Slc
	var yyhl741 bool = l >= 0
	for yyj741 := 0; ; yyj741++ {
		if yyhl741 {
			if yyj741 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys741Slc = r.DecodeBytes(yys741Slc, true, true)
		yys741 := string(yys741Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys741 {
		case "http":
			if r.TryDecodeAsNil() {
				if x.HTTP != nil {
					x.HTTP = nil
				}
			} else {
				if x.HTTP == nil {
					x.HTTP = new(HTTPIngressRuleValue)
				}
				x.HTTP.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys741)
		} // end switch yys741
	} // end for yyj741
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *IngressRuleValue) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj743 int
	var yyb743 bool
	var yyhl743 bool = l >= 0
	yyj743++
	if yyhl743 {
		yyb743 = yyj743 > l
	} else {
		yyb743 = r.CheckBreak()
	}
	if yyb743 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		if x.HTTP != nil {
			x.HTTP = nil
		}
	} else {
		if x.HTTP == nil {
			x.HTTP = new(HTTPIngressRuleValue)
		}
		x.HTTP.CodecDecodeSelf(d)
	}
	for {
		yyj743++
		if yyhl743 {
			yyb743 = yyj743 > l
		} else {
			yyb743 = r.CheckBreak()
		}
		if yyb743 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj743-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *HTTPIngressRuleValue) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym745 := z.EncBinary()
		_ = yym745
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep746 := !z.EncBinary()
			yy2arr746 := z.EncBasicHandle().StructToArray
			var yyq746 [1]bool
			_, _, _ = yysep746, yyq746, yy2arr746
			const yyr746 bool = false
			var yynn746 int
			if yyr746 || yy2arr746 {
				r.EncodeArrayStart(1)
			} else {
				yynn746 = 1
				for _, b := range yyq746 {
					if b {
						yynn746++
					}
				}
				r.EncodeMapStart(yynn746)
				yynn746 = 0
			}
			if yyr746 || yy2arr746 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if x.Paths == nil {
					r.EncodeNil()
				} else {
					yym748 := z.EncBinary()
					_ = yym748
					if false {
					} else {
						h.encSliceHTTPIngressPath(([]HTTPIngressPath)(x.Paths), e)
					}
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("paths"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				if x.Paths == nil {
					r.EncodeNil()
				} else {
					yym749 := z.EncBinary()
					_ = yym749
					if false {
					} else {
						h.encSliceHTTPIngressPath(([]HTTPIngressPath)(x.Paths), e)
					}
				}
			}
			if yyr746 || yy2arr746 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *HTTPIngressRuleValue) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym750 := z.DecBinary()
	_ = yym750
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct751 := r.ContainerType()
		if yyct751 == codecSelferValueTypeMap1234 {
			yyl751 := r.ReadMapStart()
			if yyl751 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl751, d)
			}
		} else if yyct751 == codecSelferValueTypeArray1234 {
			yyl751 := r.ReadArrayStart()
			if yyl751 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl751, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *HTTPIngressRuleValue) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys752Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys752Slc
	var yyhl752 bool = l >= 0
	for yyj752 := 0; ; yyj752++ {
		if yyhl752 {
			if yyj752 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys752Slc = r.DecodeBytes(yys752Slc, true, true)
		yys752 := string(yys752Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys752 {
		case "paths":
			if r.TryDecodeAsNil() {
				x.Paths = nil
			} else {
				yyv753 := &x.Paths
				yym754 := z.DecBinary()
				_ = yym754
				if false {
				} else {
					h.decSliceHTTPIngressPath((*[]HTTPIngressPath)(yyv753), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys752)
		} // end switch yys752
	} // end for yyj752
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *HTTPIngressRuleValue) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj755 int
	var yyb755 bool
	var yyhl755 bool = l >= 0
	yyj755++
	if yyhl755 {
		yyb755 = yyj755 > l
	} else {
		yyb755 = r.CheckBreak()
	}
	if yyb755 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Paths = nil
	} else {
		yyv756 := &x.Paths
		yym757 := z.DecBinary()
		_ = yym757
		if false {
		} else {
			h.decSliceHTTPIngressPath((*[]HTTPIngressPath)(yyv756), d)
		}
	}
	for {
		yyj755++
		if yyhl755 {
			yyb755 = yyj755 > l
		} else {
			yyb755 = r.CheckBreak()
		}
		if yyb755 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj755-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *HTTPIngressPath) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym758 := z.EncBinary()
		_ = yym758
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep759 := !z.EncBinary()
			yy2arr759 := z.EncBasicHandle().StructToArray
			var yyq759 [2]bool
			_, _, _ = yysep759, yyq759, yy2arr759
			const yyr759 bool = false
			yyq759[0] = x.Path != ""
			var yynn759 int
			if yyr759 || yy2arr759 {
				r.EncodeArrayStart(2)
			} else {
				yynn759 = 1
				for _, b := range yyq759 {
					if b {
						yynn759++
					}
				}
				r.EncodeMapStart(yynn759)
				yynn759 = 0
			}
			if yyr759 || yy2arr759 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq759[0] {
					yym761 := z.EncBinary()
					_ = yym761
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Path))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq759[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("path"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym762 := z.EncBinary()
					_ = yym762
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Path))
					}
				}
			}
			if yyr759 || yy2arr759 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yy764 := &x.Backend
				yy764.CodecEncodeSelf(e)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("backend"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yy765 := &x.Backend
				yy765.CodecEncodeSelf(e)
			}
			if yyr759 || yy2arr759 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *HTTPIngressPath) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym766 := z.DecBinary()
	_ = yym766
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct767 := r.ContainerType()
		if yyct767 == codecSelferValueTypeMap1234 {
			yyl767 := r.ReadMapStart()
			if yyl767 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl767, d)
			}
		} else if yyct767 == codecSelferValueTypeArray1234 {
			yyl767 := r.ReadArrayStart()
			if yyl767 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl767, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *HTTPIngressPath) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys768Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys768Slc
	var yyhl768 bool = l >= 0
	for yyj768 := 0; ; yyj768++ {
		if yyhl768 {
			if yyj768 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys768Slc = r.DecodeBytes(yys768Slc, true, true)
		yys768 := string(yys768Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys768 {
		case "path":
			if r.TryDecodeAsNil() {
				x.Path = ""
			} else {
				x.Path = string(r.DecodeString())
			}
		case "backend":
			if r.TryDecodeAsNil() {
				x.Backend = IngressBackend{}
			} else {
				yyv770 := &x.Backend
				yyv770.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys768)
		} // end switch yys768
	} // end for yyj768
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *HTTPIngressPath) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj771 int
	var yyb771 bool
	var yyhl771 bool = l >= 0
	yyj771++
	if yyhl771 {
		yyb771 = yyj771 > l
	} else {
		yyb771 = r.CheckBreak()
	}
	if yyb771 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Path = ""
	} else {
		x.Path = string(r.DecodeString())
	}
	yyj771++
	if yyhl771 {
		yyb771 = yyj771 > l
	} else {
		yyb771 = r.CheckBreak()
	}
	if yyb771 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Backend = IngressBackend{}
	} else {
		yyv773 := &x.Backend
		yyv773.CodecDecodeSelf(d)
	}
	for {
		yyj771++
		if yyhl771 {
			yyb771 = yyj771 > l
		} else {
			yyb771 = r.CheckBreak()
		}
		if yyb771 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj771-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *IngressBackend) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym774 := z.EncBinary()
		_ = yym774
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep775 := !z.EncBinary()
			yy2arr775 := z.EncBasicHandle().StructToArray
			var yyq775 [2]bool
			_, _, _ = yysep775, yyq775, yy2arr775
			const yyr775 bool = false
			var yynn775 int
			if yyr775 || yy2arr775 {
				r.EncodeArrayStart(2)
			} else {
				yynn775 = 2
				for _, b := range yyq775 {
					if b {
						yynn775++
					}
				}
				r.EncodeMapStart(yynn775)
				yynn775 = 0
			}
			if yyr775 || yy2arr775 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym777 := z.EncBinary()
				_ = yym777
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF81234, string(x.ServiceName))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("serviceName"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yym778 := z.EncBinary()
				_ = yym778
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF81234, string(x.ServiceName))
				}
			}
			if yyr775 || yy2arr775 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yy780 := &x.ServicePort
				yym781 := z.EncBinary()
				_ = yym781
				if false {
				} else if z.HasExtensions() && z.EncExt(yy780) {
				} else if !yym781 && z.IsJSONHandle() {
					z.EncJSONMarshal(yy780)
				} else {
					z.EncFallback(yy780)
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("servicePort"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yy782 := &x.ServicePort
				yym783 := z.EncBinary()
				_ = yym783
				if false {
				} else if z.HasExtensions() && z.EncExt(yy782) {
				} else if !yym783 && z.IsJSONHandle() {
					z.EncJSONMarshal(yy782)
				} else {
					z.EncFallback(yy782)
				}
			}
			if yyr775 || yy2arr775 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *IngressBackend) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym784 := z.DecBinary()
	_ = yym784
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct785 := r.ContainerType()
		if yyct785 == codecSelferValueTypeMap1234 {
			yyl785 := r.ReadMapStart()
			if yyl785 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl785, d)
			}
		} else if yyct785 == codecSelferValueTypeArray1234 {
			yyl785 := r.ReadArrayStart()
			if yyl785 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl785, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *IngressBackend) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys786Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys786Slc
	var yyhl786 bool = l >= 0
	for yyj786 := 0; ; yyj786++ {
		if yyhl786 {
			if yyj786 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys786Slc = r.DecodeBytes(yys786Slc, true, true)
		yys786 := string(yys786Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys786 {
		case "serviceName":
			if r.TryDecodeAsNil() {
				x.ServiceName = ""
			} else {
				x.ServiceName = string(r.DecodeString())
			}
		case "servicePort":
			if r.TryDecodeAsNil() {
				x.ServicePort = pkg5_intstr.IntOrString{}
			} else {
				yyv788 := &x.ServicePort
				yym789 := z.DecBinary()
				_ = yym789
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv788) {
				} else if !yym789 && z.IsJSONHandle() {
					z.DecJSONUnmarshal(yyv788)
				} else {
					z.DecFallback(yyv788, false)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys786)
		} // end switch yys786
	} // end for yyj786
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *IngressBackend) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj790 int
	var yyb790 bool
	var yyhl790 bool = l >= 0
	yyj790++
	if yyhl790 {
		yyb790 = yyj790 > l
	} else {
		yyb790 = r.CheckBreak()
	}
	if yyb790 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ServiceName = ""
	} else {
		x.ServiceName = string(r.DecodeString())
	}
	yyj790++
	if yyhl790 {
		yyb790 = yyj790 > l
	} else {
		yyb790 = r.CheckBreak()
	}
	if yyb790 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ServicePort = pkg5_intstr.IntOrString{}
	} else {
		yyv792 := &x.ServicePort
		yym793 := z.DecBinary()
		_ = yym793
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv792) {
		} else if !yym793 && z.IsJSONHandle() {
			z.DecJSONUnmarshal(yyv792)
		} else {
			z.DecFallback(yyv792, false)
		}
	}
	for {
		yyj790++
		if yyhl790 {
			yyb790 = yyj790 > l
		} else {
			yyb790 = r.CheckBreak()
		}
		if yyb790 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj790-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *ReplicaSet) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym794 := z.EncBinary()
		_ = yym794
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep795 := !z.EncBinary()
			yy2arr795 := z.EncBasicHandle().StructToArray
			var yyq795 [5]bool
			_, _, _ = yysep795, yyq795, yy2arr795
			const yyr795 bool = false
			yyq795[0] = x.Kind != ""
			yyq795[1] = x.APIVersion != ""
			yyq795[2] = true
			yyq795[3] = true
			yyq795[4] = true
			var yynn795 int
			if yyr795 || yy2arr795 {
				r.EncodeArrayStart(5)
			} else {
				yynn795 = 0
				for _, b := range yyq795 {
					if b {
						yynn795++
					}
				}
				r.EncodeMapStart(yynn795)
				yynn795 = 0
			}
			if yyr795 || yy2arr795 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq795[0] {
					yym797 := z.EncBinary()
					_ = yym797
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq795[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym798 := z.EncBinary()
					_ = yym798
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr795 || yy2arr795 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq795[1] {
					yym800 := z.EncBinary()
					_ = yym800
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq795[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym801 := z.EncBinary()
					_ = yym801
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr795 || yy2arr795 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq795[2] {
					yy803 := &x.ObjectMeta
					yy803.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq795[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy804 := &x.ObjectMeta
					yy804.CodecEncodeSelf(e)
				}
			}
			if yyr795 || yy2arr795 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq795[3] {
					yy806 := &x.Spec
					yy806.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq795[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("spec"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy807 := &x.Spec
					yy807.CodecEncodeSelf(e)
				}
			}
			if yyr795 || yy2arr795 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq795[4] {
					yy809 := &x.Status
					yy809.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq795[4] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("status"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy810 := &x.Status
					yy810.CodecEncodeSelf(e)
				}
			}
			if yyr795 || yy2arr795 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *ReplicaSet) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym811 := z.DecBinary()
	_ = yym811
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct812 := r.ContainerType()
		if yyct812 == codecSelferValueTypeMap1234 {
			yyl812 := r.ReadMapStart()
			if yyl812 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl812, d)
			}
		} else if yyct812 == codecSelferValueTypeArray1234 {
			yyl812 := r.ReadArrayStart()
			if yyl812 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl812, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *ReplicaSet) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys813Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys813Slc
	var yyhl813 bool = l >= 0
	for yyj813 := 0; ; yyj813++ {
		if yyhl813 {
			if yyj813 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys813Slc = r.DecodeBytes(yys813Slc, true, true)
		yys813 := string(yys813Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys813 {
		case "kind":
			if r.TryDecodeAsNil() {
				x.Kind = ""
			} else {
				x.Kind = string(r.DecodeString())
			}
		case "apiVersion":
			if r.TryDecodeAsNil() {
				x.APIVersion = ""
			} else {
				x.APIVersion = string(r.DecodeString())
			}
		case "metadata":
			if r.TryDecodeAsNil() {
				x.ObjectMeta = pkg2_api.ObjectMeta{}
			} else {
				yyv816 := &x.ObjectMeta
				yyv816.CodecDecodeSelf(d)
			}
		case "spec":
			if r.TryDecodeAsNil() {
				x.Spec = ReplicaSetSpec{}
			} else {
				yyv817 := &x.Spec
				yyv817.CodecDecodeSelf(d)
			}
		case "status":
			if r.TryDecodeAsNil() {
				x.Status = ReplicaSetStatus{}
			} else {
				yyv818 := &x.Status
				yyv818.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys813)
		} // end switch yys813
	} // end for yyj813
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *ReplicaSet) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj819 int
	var yyb819 bool
	var yyhl819 bool = l >= 0
	yyj819++
	if yyhl819 {
		yyb819 = yyj819 > l
	} else {
		yyb819 = r.CheckBreak()
	}
	if yyb819 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj819++
	if yyhl819 {
		yyb819 = yyj819 > l
	} else {
		yyb819 = r.CheckBreak()
	}
	if yyb819 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj819++
	if yyhl819 {
		yyb819 = yyj819 > l
	} else {
		yyb819 = r.CheckBreak()
	}
	if yyb819 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ObjectMeta = pkg2_api.ObjectMeta{}
	} else {
		yyv822 := &x.ObjectMeta
		yyv822.CodecDecodeSelf(d)
	}
	yyj819++
	if yyhl819 {
		yyb819 = yyj819 > l
	} else {
		yyb819 = r.CheckBreak()
	}
	if yyb819 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Spec = ReplicaSetSpec{}
	} else {
		yyv823 := &x.Spec
		yyv823.CodecDecodeSelf(d)
	}
	yyj819++
	if yyhl819 {
		yyb819 = yyj819 > l
	} else {
		yyb819 = r.CheckBreak()
	}
	if yyb819 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Status = ReplicaSetStatus{}
	} else {
		yyv824 := &x.Status
		yyv824.CodecDecodeSelf(d)
	}
	for {
		yyj819++
		if yyhl819 {
			yyb819 = yyj819 > l
		} else {
			yyb819 = r.CheckBreak()
		}
		if yyb819 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj819-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *ReplicaSetList) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym825 := z.EncBinary()
		_ = yym825
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep826 := !z.EncBinary()
			yy2arr826 := z.EncBasicHandle().StructToArray
			var yyq826 [4]bool
			_, _, _ = yysep826, yyq826, yy2arr826
			const yyr826 bool = false
			yyq826[0] = x.Kind != ""
			yyq826[1] = x.APIVersion != ""
			yyq826[2] = true
			var yynn826 int
			if yyr826 || yy2arr826 {
				r.EncodeArrayStart(4)
			} else {
				yynn826 = 1
				for _, b := range yyq826 {
					if b {
						yynn826++
					}
				}
				r.EncodeMapStart(yynn826)
				yynn826 = 0
			}
			if yyr826 || yy2arr826 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq826[0] {
					yym828 := z.EncBinary()
					_ = yym828
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq826[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym829 := z.EncBinary()
					_ = yym829
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr826 || yy2arr826 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq826[1] {
					yym831 := z.EncBinary()
					_ = yym831
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq826[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym832 := z.EncBinary()
					_ = yym832
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr826 || yy2arr826 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq826[2] {
					yy834 := &x.ListMeta
					yym835 := z.EncBinary()
					_ = yym835
					if false {
					} else if z.HasExtensions() && z.EncExt(yy834) {
					} else {
						z.EncFallback(yy834)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq826[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy836 := &x.ListMeta
					yym837 := z.EncBinary()
					_ = yym837
					if false {
					} else if z.HasExtensions() && z.EncExt(yy836) {
					} else {
						z.EncFallback(yy836)
					}
				}
			}
			if yyr826 || yy2arr826 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym839 := z.EncBinary()
					_ = yym839
					if false {
					} else {
						h.encSliceReplicaSet(([]ReplicaSet)(x.Items), e)
					}
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("items"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym840 := z.EncBinary()
					_ = yym840
					if false {
					} else {
						h.encSliceReplicaSet(([]ReplicaSet)(x.Items), e)
					}
				}
			}
			if yyr826 || yy2arr826 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *ReplicaSetList) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym841 := z.DecBinary()
	_ = yym841
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct842 := r.ContainerType()
		if yyct842 == codecSelferValueTypeMap1234 {
			yyl842 := r.ReadMapStart()
			if yyl842 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl842, d)
			}
		} else if yyct842 == codecSelferValueTypeArray1234 {
			yyl842 := r.ReadArrayStart()
			if yyl842 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl842, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *ReplicaSetList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys843Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys843Slc
	var yyhl843 bool = l >= 0
	for yyj843 := 0; ; yyj843++ {
		if yyhl843 {
			if yyj843 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys843Slc = r.DecodeBytes(yys843Slc, true, true)
		yys843 := string(yys843Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys843 {
		case "kind":
			if r.TryDecodeAsNil() {
				x.Kind = ""
			} else {
				x.Kind = string(r.DecodeString())
			}
		case "apiVersion":
			if r.TryDecodeAsNil() {
				x.APIVersion = ""
			} else {
				x.APIVersion = string(r.DecodeString())
			}
		case "metadata":
			if r.TryDecodeAsNil() {
				x.ListMeta = pkg1_unversioned.ListMeta{}
			} else {
				yyv846 := &x.ListMeta
				yym847 := z.DecBinary()
				_ = yym847
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv846) {
				} else {
					z.DecFallback(yyv846, false)
				}
			}
		case "items":
			if r.TryDecodeAsNil() {
				x.Items = nil
			} else {
				yyv848 := &x.Items
				yym849 := z.DecBinary()
				_ = yym849
				if false {
				} else {
					h.decSliceReplicaSet((*[]ReplicaSet)(yyv848), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys843)
		} // end switch yys843
	} // end for yyj843
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *ReplicaSetList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj850 int
	var yyb850 bool
	var yyhl850 bool = l >= 0
	yyj850++
	if yyhl850 {
		yyb850 = yyj850 > l
	} else {
		yyb850 = r.CheckBreak()
	}
	if yyb850 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj850++
	if yyhl850 {
		yyb850 = yyj850 > l
	} else {
		yyb850 = r.CheckBreak()
	}
	if yyb850 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj850++
	if yyhl850 {
		yyb850 = yyj850 > l
	} else {
		yyb850 = r.CheckBreak()
	}
	if yyb850 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ListMeta = pkg1_unversioned.ListMeta{}
	} else {
		yyv853 := &x.ListMeta
		yym854 := z.DecBinary()
		_ = yym854
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv853) {
		} else {
			z.DecFallback(yyv853, false)
		}
	}
	yyj850++
	if yyhl850 {
		yyb850 = yyj850 > l
	} else {
		yyb850 = r.CheckBreak()
	}
	if yyb850 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Items = nil
	} else {
		yyv855 := &x.Items
		yym856 := z.DecBinary()
		_ = yym856
		if false {
		} else {
			h.decSliceReplicaSet((*[]ReplicaSet)(yyv855), d)
		}
	}
	for {
		yyj850++
		if yyhl850 {
			yyb850 = yyj850 > l
		} else {
			yyb850 = r.CheckBreak()
		}
		if yyb850 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj850-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *ReplicaSetSpec) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym857 := z.EncBinary()
		_ = yym857
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep858 := !z.EncBinary()
			yy2arr858 := z.EncBasicHandle().StructToArray
			var yyq858 [4]bool
			_, _, _ = yysep858, yyq858, yy2arr858
			const yyr858 bool = false
			yyq858[1] = x.MinReadySeconds != 0
			yyq858[2] = x.Selector != nil
			yyq858[3] = true
			var yynn858 int
			if yyr858 || yy2arr858 {
				r.EncodeArrayStart(4)
			} else {
				yynn858 = 1
				for _, b := range yyq858 {
					if b {
						yynn858++
					}
				}
				r.EncodeMapStart(yynn858)
				yynn858 = 0
			}
			if yyr858 || yy2arr858 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym860 := z.EncBinary()
				_ = yym860
				if false {
				} else {
					r.EncodeInt(int64(x.Replicas))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("replicas"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yym861 := z.EncBinary()
				_ = yym861
				if false {
				} else {
					r.EncodeInt(int64(x.Replicas))
				}
			}
			if yyr858 || yy2arr858 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq858[1] {
					yym863 := z.EncBinary()
					_ = yym863
					if false {
					} else {
						r.EncodeInt(int64(x.MinReadySeconds))
					}
				} else {
					r.EncodeInt(0)
				}
			} else {
				if yyq858[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("minReadySeconds"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym864 := z.EncBinary()
					_ = yym864
					if false {
					} else {
						r.EncodeInt(int64(x.MinReadySeconds))
					}
				}
			}
			if yyr858 || yy2arr858 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq858[2] {
					if x.Selector == nil {
						r.EncodeNil()
					} else {
						yym866 := z.EncBinary()
						_ = yym866
						if false {
						} else if z.HasExtensions() && z.EncExt(x.Selector) {
						} else {
							z.EncFallback(x.Selector)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq858[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("selector"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.Selector == nil {
						r.EncodeNil()
					} else {
						yym867 := z.EncBinary()
						_ = yym867
						if false {
						} else if z.HasExtensions() && z.EncExt(x.Selector) {
						} else {
							z.EncFallback(x.Selector)
						}
					}
				}
			}
			if yyr858 || yy2arr858 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq858[3] {
					yy869 := &x.Template
					yy869.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq858[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("template"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy870 := &x.Template
					yy870.CodecEncodeSelf(e)
				}
			}
			if yyr858 || yy2arr858 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *ReplicaSetSpec) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym871 := z.DecBinary()
	_ = yym871
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct872 := r.ContainerType()
		if yyct872 == codecSelferValueTypeMap1234 {
			yyl872 := r.ReadMapStart()
			if yyl872 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl872, d)
			}
		} else if yyct872 == codecSelferValueTypeArray1234 {
			yyl872 := r.ReadArrayStart()
			if yyl872 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl872, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *ReplicaSetSpec) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys873Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys873Slc
	var yyhl873 bool = l >= 0
	for yyj873 := 0; ; yyj873++ {
		if yyhl873 {
			if yyj873 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys873Slc = r.DecodeBytes(yys873Slc, true, true)
		yys873 := string(yys873Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys873 {
		case "replicas":
			if r.TryDecodeAsNil() {
				x.Replicas = 0
			} else {
				x.Replicas = int32(r.DecodeInt(32))
			}
		case "minReadySeconds":
			if r.TryDecodeAsNil() {
				x.MinReadySeconds = 0
			} else {
				x.MinReadySeconds = int32(r.DecodeInt(32))
			}
		case "selector":
			if r.TryDecodeAsNil() {
				if x.Selector != nil {
					x.Selector = nil
				}
			} else {
				if x.Selector == nil {
					x.Selector = new(pkg1_unversioned.LabelSelector)
				}
				yym877 := z.DecBinary()
				_ = yym877
				if false {
				} else if z.HasExtensions() && z.DecExt(x.Selector) {
				} else {
					z.DecFallback(x.Selector, false)
				}
			}
		case "template":
			if r.TryDecodeAsNil() {
				x.Template = pkg2_api.PodTemplateSpec{}
			} else {
				yyv878 := &x.Template
				yyv878.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys873)
		} // end switch yys873
	} // end for yyj873
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *ReplicaSetSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj879 int
	var yyb879 bool
	var yyhl879 bool = l >= 0
	yyj879++
	if yyhl879 {
		yyb879 = yyj879 > l
	} else {
		yyb879 = r.CheckBreak()
	}
	if yyb879 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Replicas = 0
	} else {
		x.Replicas = int32(r.DecodeInt(32))
	}
	yyj879++
	if yyhl879 {
		yyb879 = yyj879 > l
	} else {
		yyb879 = r.CheckBreak()
	}
	if yyb879 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.MinReadySeconds = 0
	} else {
		x.MinReadySeconds = int32(r.DecodeInt(32))
	}
	yyj879++
	if yyhl879 {
		yyb879 = yyj879 > l
	} else {
		yyb879 = r.CheckBreak()
	}
	if yyb879 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		if x.Selector != nil {
			x.Selector = nil
		}
	} else {
		if x.Selector == nil {
			x.Selector = new(pkg1_unversioned.LabelSelector)
		}
		yym883 := z.DecBinary()
		_ = yym883
		if false {
		} else if z.HasExtensions() && z.DecExt(x.Selector) {
		} else {
			z.DecFallback(x.Selector, false)
		}
	}
	yyj879++
	if yyhl879 {
		yyb879 = yyj879 > l
	} else {
		yyb879 = r.CheckBreak()
	}
	if yyb879 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Template = pkg2_api.PodTemplateSpec{}
	} else {
		yyv884 := &x.Template
		yyv884.CodecDecodeSelf(d)
	}
	for {
		yyj879++
		if yyhl879 {
			yyb879 = yyj879 > l
		} else {
			yyb879 = r.CheckBreak()
		}
		if yyb879 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj879-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *ReplicaSetStatus) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym885 := z.EncBinary()
		_ = yym885
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep886 := !z.EncBinary()
			yy2arr886 := z.EncBasicHandle().StructToArray
			var yyq886 [5]bool
			_, _, _ = yysep886, yyq886, yy2arr886
			const yyr886 bool = false
			yyq886[1] = x.FullyLabeledReplicas != 0
			yyq886[2] = x.ReadyReplicas != 0
			yyq886[3] = x.AvailableReplicas != 0
			yyq886[4] = x.ObservedGeneration != 0
			var yynn886 int
			if yyr886 || yy2arr886 {
				r.EncodeArrayStart(5)
			} else {
				yynn886 = 1
				for _, b := range yyq886 {
					if b {
						yynn886++
					}
				}
				r.EncodeMapStart(yynn886)
				yynn886 = 0
			}
			if yyr886 || yy2arr886 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym888 := z.EncBinary()
				_ = yym888
				if false {
				} else {
					r.EncodeInt(int64(x.Replicas))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("replicas"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yym889 := z.EncBinary()
				_ = yym889
				if false {
				} else {
					r.EncodeInt(int64(x.Replicas))
				}
			}
			if yyr886 || yy2arr886 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq886[1] {
					yym891 := z.EncBinary()
					_ = yym891
					if false {
					} else {
						r.EncodeInt(int64(x.FullyLabeledReplicas))
					}
				} else {
					r.EncodeInt(0)
				}
			} else {
				if yyq886[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("fullyLabeledReplicas"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym892 := z.EncBinary()
					_ = yym892
					if false {
					} else {
						r.EncodeInt(int64(x.FullyLabeledReplicas))
					}
				}
			}
			if yyr886 || yy2arr886 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq886[2] {
					yym894 := z.EncBinary()
					_ = yym894
					if false {
					} else {
						r.EncodeInt(int64(x.ReadyReplicas))
					}
				} else {
					r.EncodeInt(0)
				}
			} else {
				if yyq886[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("readyReplicas"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym895 := z.EncBinary()
					_ = yym895
					if false {
					} else {
						r.EncodeInt(int64(x.ReadyReplicas))
					}
				}
			}
			if yyr886 || yy2arr886 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq886[3] {
					yym897 := z.EncBinary()
					_ = yym897
					if false {
					} else {
						r.EncodeInt(int64(x.AvailableReplicas))
					}
				} else {
					r.EncodeInt(0)
				}
			} else {
				if yyq886[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("availableReplicas"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym898 := z.EncBinary()
					_ = yym898
					if false {
					} else {
						r.EncodeInt(int64(x.AvailableReplicas))
					}
				}
			}
			if yyr886 || yy2arr886 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq886[4] {
					yym900 := z.EncBinary()
					_ = yym900
					if false {
					} else {
						r.EncodeInt(int64(x.ObservedGeneration))
					}
				} else {
					r.EncodeInt(0)
				}
			} else {
				if yyq886[4] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("observedGeneration"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym901 := z.EncBinary()
					_ = yym901
					if false {
					} else {
						r.EncodeInt(int64(x.ObservedGeneration))
					}
				}
			}
			if yyr886 || yy2arr886 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *ReplicaSetStatus) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym902 := z.DecBinary()
	_ = yym902
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct903 := r.ContainerType()
		if yyct903 == codecSelferValueTypeMap1234 {
			yyl903 := r.ReadMapStart()
			if yyl903 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl903, d)
			}
		} else if yyct903 == codecSelferValueTypeArray1234 {
			yyl903 := r.ReadArrayStart()
			if yyl903 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl903, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *ReplicaSetStatus) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys904Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys904Slc
	var yyhl904 bool = l >= 0
	for yyj904 := 0; ; yyj904++ {
		if yyhl904 {
			if yyj904 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys904Slc = r.DecodeBytes(yys904Slc, true, true)
		yys904 := string(yys904Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys904 {
		case "replicas":
			if r.TryDecodeAsNil() {
				x.Replicas = 0
			} else {
				x.Replicas = int32(r.DecodeInt(32))
			}
		case "fullyLabeledReplicas":
			if r.TryDecodeAsNil() {
				x.FullyLabeledReplicas = 0
			} else {
				x.FullyLabeledReplicas = int32(r.DecodeInt(32))
			}
		case "readyReplicas":
			if r.TryDecodeAsNil() {
				x.ReadyReplicas = 0
			} else {
				x.ReadyReplicas = int32(r.DecodeInt(32))
			}
		case "availableReplicas":
			if r.TryDecodeAsNil() {
				x.AvailableReplicas = 0
			} else {
				x.AvailableReplicas = int32(r.DecodeInt(32))
			}
		case "observedGeneration":
			if r.TryDecodeAsNil() {
				x.ObservedGeneration = 0
			} else {
				x.ObservedGeneration = int64(r.DecodeInt(64))
			}
		default:
			z.DecStructFieldNotFound(-1, yys904)
		} // end switch yys904
	} // end for yyj904
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *ReplicaSetStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj910 int
	var yyb910 bool
	var yyhl910 bool = l >= 0
	yyj910++
	if yyhl910 {
		yyb910 = yyj910 > l
	} else {
		yyb910 = r.CheckBreak()
	}
	if yyb910 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Replicas = 0
	} else {
		x.Replicas = int32(r.DecodeInt(32))
	}
	yyj910++
	if yyhl910 {
		yyb910 = yyj910 > l
	} else {
		yyb910 = r.CheckBreak()
	}
	if yyb910 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.FullyLabeledReplicas = 0
	} else {
		x.FullyLabeledReplicas = int32(r.DecodeInt(32))
	}
	yyj910++
	if yyhl910 {
		yyb910 = yyj910 > l
	} else {
		yyb910 = r.CheckBreak()
	}
	if yyb910 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ReadyReplicas = 0
	} else {
		x.ReadyReplicas = int32(r.DecodeInt(32))
	}
	yyj910++
	if yyhl910 {
		yyb910 = yyj910 > l
	} else {
		yyb910 = r.CheckBreak()
	}
	if yyb910 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.AvailableReplicas = 0
	} else {
		x.AvailableReplicas = int32(r.DecodeInt(32))
	}
	yyj910++
	if yyhl910 {
		yyb910 = yyj910 > l
	} else {
		yyb910 = r.CheckBreak()
	}
	if yyb910 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ObservedGeneration = 0
	} else {
		x.ObservedGeneration = int64(r.DecodeInt(64))
	}
	for {
		yyj910++
		if yyhl910 {
			yyb910 = yyj910 > l
		} else {
			yyb910 = r.CheckBreak()
		}
		if yyb910 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj910-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *PodSecurityPolicy) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym916 := z.EncBinary()
		_ = yym916
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep917 := !z.EncBinary()
			yy2arr917 := z.EncBasicHandle().StructToArray
			var yyq917 [4]bool
			_, _, _ = yysep917, yyq917, yy2arr917
			const yyr917 bool = false
			yyq917[0] = x.Kind != ""
			yyq917[1] = x.APIVersion != ""
			yyq917[2] = true
			yyq917[3] = true
			var yynn917 int
			if yyr917 || yy2arr917 {
				r.EncodeArrayStart(4)
			} else {
				yynn917 = 0
				for _, b := range yyq917 {
					if b {
						yynn917++
					}
				}
				r.EncodeMapStart(yynn917)
				yynn917 = 0
			}
			if yyr917 || yy2arr917 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq917[0] {
					yym919 := z.EncBinary()
					_ = yym919
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq917[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym920 := z.EncBinary()
					_ = yym920
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr917 || yy2arr917 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq917[1] {
					yym922 := z.EncBinary()
					_ = yym922
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq917[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym923 := z.EncBinary()
					_ = yym923
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr917 || yy2arr917 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq917[2] {
					yy925 := &x.ObjectMeta
					yy925.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq917[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy926 := &x.ObjectMeta
					yy926.CodecEncodeSelf(e)
				}
			}
			if yyr917 || yy2arr917 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq917[3] {
					yy928 := &x.Spec
					yy928.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq917[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("spec"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy929 := &x.Spec
					yy929.CodecEncodeSelf(e)
				}
			}
			if yyr917 || yy2arr917 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *PodSecurityPolicy) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym930 := z.DecBinary()
	_ = yym930
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct931 := r.ContainerType()
		if yyct931 == codecSelferValueTypeMap1234 {
			yyl931 := r.ReadMapStart()
			if yyl931 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl931, d)
			}
		} else if yyct931 == codecSelferValueTypeArray1234 {
			yyl931 := r.ReadArrayStart()
			if yyl931 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl931, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *PodSecurityPolicy) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys932Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys932Slc
	var yyhl932 bool = l >= 0
	for yyj932 := 0; ; yyj932++ {
		if yyhl932 {
			if yyj932 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys932Slc = r.DecodeBytes(yys932Slc, true, true)
		yys932 := string(yys932Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys932 {
		case "kind":
			if r.TryDecodeAsNil() {
				x.Kind = ""
			} else {
				x.Kind = string(r.DecodeString())
			}
		case "apiVersion":
			if r.TryDecodeAsNil() {
				x.APIVersion = ""
			} else {
				x.APIVersion = string(r.DecodeString())
			}
		case "metadata":
			if r.TryDecodeAsNil() {
				x.ObjectMeta = pkg2_api.ObjectMeta{}
			} else {
				yyv935 := &x.ObjectMeta
				yyv935.CodecDecodeSelf(d)
			}
		case "spec":
			if r.TryDecodeAsNil() {
				x.Spec = PodSecurityPolicySpec{}
			} else {
				yyv936 := &x.Spec
				yyv936.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys932)
		} // end switch yys932
	} // end for yyj932
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *PodSecurityPolicy) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj937 int
	var yyb937 bool
	var yyhl937 bool = l >= 0
	yyj937++
	if yyhl937 {
		yyb937 = yyj937 > l
	} else {
		yyb937 = r.CheckBreak()
	}
	if yyb937 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj937++
	if yyhl937 {
		yyb937 = yyj937 > l
	} else {
		yyb937 = r.CheckBreak()
	}
	if yyb937 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj937++
	if yyhl937 {
		yyb937 = yyj937 > l
	} else {
		yyb937 = r.CheckBreak()
	}
	if yyb937 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ObjectMeta = pkg2_api.ObjectMeta{}
	} else {
		yyv940 := &x.ObjectMeta
		yyv940.CodecDecodeSelf(d)
	}
	yyj937++
	if yyhl937 {
		yyb937 = yyj937 > l
	} else {
		yyb937 = r.CheckBreak()
	}
	if yyb937 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Spec = PodSecurityPolicySpec{}
	} else {
		yyv941 := &x.Spec
		yyv941.CodecDecodeSelf(d)
	}
	for {
		yyj937++
		if yyhl937 {
			yyb937 = yyj937 > l
		} else {
			yyb937 = r.CheckBreak()
		}
		if yyb937 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj937-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *PodSecurityPolicySpec) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym942 := z.EncBinary()
		_ = yym942
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep943 := !z.EncBinary()
			yy2arr943 := z.EncBasicHandle().StructToArray
			var yyq943 [14]bool
			_, _, _ = yysep943, yyq943, yy2arr943
			const yyr943 bool = false
			yyq943[0] = x.Privileged != false
			yyq943[1] = len(x.DefaultAddCapabilities) != 0
			yyq943[2] = len(x.RequiredDropCapabilities) != 0
			yyq943[3] = len(x.AllowedCapabilities) != 0
			yyq943[4] = len(x.Volumes) != 0
			yyq943[5] = x.HostNetwork != false
			yyq943[6] = len(x.HostPorts) != 0
			yyq943[7] = x.HostPID != false
			yyq943[8] = x.HostIPC != false
			yyq943[13] = x.ReadOnlyRootFilesystem != false
			var yynn943 int
			if yyr943 || yy2arr943 {
				r.EncodeArrayStart(14)
			} else {
				yynn943 = 4
				for _, b := range yyq943 {
					if b {
						yynn943++
					}
				}
				r.EncodeMapStart(yynn943)
				yynn943 = 0
			}
			if yyr943 || yy2arr943 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq943[0] {
					yym945 := z.EncBinary()
					_ = yym945
					if false {
					} else {
						r.EncodeBool(bool(x.Privileged))
					}
				} else {
					r.EncodeBool(false)
				}
			} else {
				if yyq943[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("privileged"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym946 := z.EncBinary()
					_ = yym946
					if false {
					} else {
						r.EncodeBool(bool(x.Privileged))
					}
				}
			}
			if yyr943 || yy2arr943 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq943[1] {
					if x.DefaultAddCapabilities == nil {
						r.EncodeNil()
					} else {
						yym948 := z.EncBinary()
						_ = yym948
						if false {
						} else {
							h.encSliceapi_Capability(([]pkg2_api.Capability)(x.DefaultAddCapabilities), e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq943[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("defaultAddCapabilities"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.DefaultAddCapabilities == nil {
						r.EncodeNil()
					} else {
						yym949 := z.EncBinary()
						_ = yym949
						if false {
						} else {
							h.encSliceapi_Capability(([]pkg2_api.Capability)(x.DefaultAddCapabilities), e)
						}
					}
				}
			}
			if yyr943 || yy2arr943 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq943[2] {
					if x.RequiredDropCapabilities == nil {
						r.EncodeNil()
					} else {
						yym951 := z.EncBinary()
						_ = yym951
						if false {
						} else {
							h.encSliceapi_Capability(([]pkg2_api.Capability)(x.RequiredDropCapabilities), e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq943[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("requiredDropCapabilities"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.RequiredDropCapabilities == nil {
						r.EncodeNil()
					} else {
						yym952 := z.EncBinary()
						_ = yym952
						if false {
						} else {
							h.encSliceapi_Capability(([]pkg2_api.Capability)(x.RequiredDropCapabilities), e)
						}
					}
				}
			}
			if yyr943 || yy2arr943 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq943[3] {
					if x.AllowedCapabilities == nil {
						r.EncodeNil()
					} else {
						yym954 := z.EncBinary()
						_ = yym954
						if false {
						} else {
							h.encSliceapi_Capability(([]pkg2_api.Capability)(x.AllowedCapabilities), e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq943[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("allowedCapabilities"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.AllowedCapabilities == nil {
						r.EncodeNil()
					} else {
						yym955 := z.EncBinary()
						_ = yym955
						if false {
						} else {
							h.encSliceapi_Capability(([]pkg2_api.Capability)(x.AllowedCapabilities), e)
						}
					}
				}
			}
			if yyr943 || yy2arr943 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq943[4] {
					if x.Volumes == nil {
						r.EncodeNil()
					} else {
						yym957 := z.EncBinary()
						_ = yym957
						if false {
						} else {
							h.encSliceFSType(([]FSType)(x.Volumes), e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq943[4] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("volumes"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.Volumes == nil {
						r.EncodeNil()
					} else {
						yym958 := z.EncBinary()
						_ = yym958
						if false {
						} else {
							h.encSliceFSType(([]FSType)(x.Volumes), e)
						}
					}
				}
			}
			if yyr943 || yy2arr943 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq943[5] {
					yym960 := z.EncBinary()
					_ = yym960
					if false {
					} else {
						r.EncodeBool(bool(x.HostNetwork))
					}
				} else {
					r.EncodeBool(false)
				}
			} else {
				if yyq943[5] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("hostNetwork"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym961 := z.EncBinary()
					_ = yym961
					if false {
					} else {
						r.EncodeBool(bool(x.HostNetwork))
					}
				}
			}
			if yyr943 || yy2arr943 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq943[6] {
					if x.HostPorts == nil {
						r.EncodeNil()
					} else {
						yym963 := z.EncBinary()
						_ = yym963
						if false {
						} else {
							h.encSliceHostPortRange(([]HostPortRange)(x.HostPorts), e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq943[6] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("hostPorts"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.HostPorts == nil {
						r.EncodeNil()
					} else {
						yym964 := z.EncBinary()
						_ = yym964
						if false {
						} else {
							h.encSliceHostPortRange(([]HostPortRange)(x.HostPorts), e)
						}
					}
				}
			}
			if yyr943 || yy2arr943 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq943[7] {
					yym966 := z.EncBinary()
					_ = yym966
					if false {
					} else {
						r.EncodeBool(bool(x.HostPID))
					}
				} else {
					r.EncodeBool(false)
				}
			} else {
				if yyq943[7] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("hostPID"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym967 := z.EncBinary()
					_ = yym967
					if false {
					} else {
						r.EncodeBool(bool(x.HostPID))
					}
				}
			}
			if yyr943 || yy2arr943 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq943[8] {
					yym969 := z.EncBinary()
					_ = yym969
					if false {
					} else {
						r.EncodeBool(bool(x.HostIPC))
					}
				} else {
					r.EncodeBool(false)
				}
			} else {
				if yyq943[8] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("hostIPC"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym970 := z.EncBinary()
					_ = yym970
					if false {
					} else {
						r.EncodeBool(bool(x.HostIPC))
					}
				}
			}
			if yyr943 || yy2arr943 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yy972 := &x.SELinux
				yy972.CodecEncodeSelf(e)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("seLinux"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yy973 := &x.SELinux
				yy973.CodecEncodeSelf(e)
			}
			if yyr943 || yy2arr943 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yy975 := &x.RunAsUser
				yy975.CodecEncodeSelf(e)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("runAsUser"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yy976 := &x.RunAsUser
				yy976.CodecEncodeSelf(e)
			}
			if yyr943 || yy2arr943 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yy978 := &x.SupplementalGroups
				yy978.CodecEncodeSelf(e)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("supplementalGroups"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yy979 := &x.SupplementalGroups
				yy979.CodecEncodeSelf(e)
			}
			if yyr943 || yy2arr943 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yy981 := &x.FSGroup
				yy981.CodecEncodeSelf(e)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("fsGroup"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yy982 := &x.FSGroup
				yy982.CodecEncodeSelf(e)
			}
			if yyr943 || yy2arr943 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq943[13] {
					yym984 := z.EncBinary()
					_ = yym984
					if false {
					} else {
						r.EncodeBool(bool(x.ReadOnlyRootFilesystem))
					}
				} else {
					r.EncodeBool(false)
				}
			} else {
				if yyq943[13] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("readOnlyRootFilesystem"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym985 := z.EncBinary()
					_ = yym985
					if false {
					} else {
						r.EncodeBool(bool(x.ReadOnlyRootFilesystem))
					}
				}
			}
			if yyr943 || yy2arr943 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *PodSecurityPolicySpec) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym986 := z.DecBinary()
	_ = yym986
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct987 := r.ContainerType()
		if yyct987 == codecSelferValueTypeMap1234 {
			yyl987 := r.ReadMapStart()
			if yyl987 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl987, d)
			}
		} else if yyct987 == codecSelferValueTypeArray1234 {
			yyl987 := r.ReadArrayStart()
			if yyl987 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl987, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *PodSecurityPolicySpec) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys988Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys988Slc
	var yyhl988 bool = l >= 0
	for yyj988 := 0; ; yyj988++ {
		if yyhl988 {
			if yyj988 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys988Slc = r.DecodeBytes(yys988Slc, true, true)
		yys988 := string(yys988Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys988 {
		case "privileged":
			if r.TryDecodeAsNil() {
				x.Privileged = false
			} else {
				x.Privileged = bool(r.DecodeBool())
			}
		case "defaultAddCapabilities":
			if r.TryDecodeAsNil() {
				x.DefaultAddCapabilities = nil
			} else {
				yyv990 := &x.DefaultAddCapabilities
				yym991 := z.DecBinary()
				_ = yym991
				if false {
				} else {
					h.decSliceapi_Capability((*[]pkg2_api.Capability)(yyv990), d)
				}
			}
		case "requiredDropCapabilities":
			if r.TryDecodeAsNil() {
				x.RequiredDropCapabilities = nil
			} else {
				yyv992 := &x.RequiredDropCapabilities
				yym993 := z.DecBinary()
				_ = yym993
				if false {
				} else {
					h.decSliceapi_Capability((*[]pkg2_api.Capability)(yyv992), d)
				}
			}
		case "allowedCapabilities":
			if r.TryDecodeAsNil() {
				x.AllowedCapabilities = nil
			} else {
				yyv994 := &x.AllowedCapabilities
				yym995 := z.DecBinary()
				_ = yym995
				if false {
				} else {
					h.decSliceapi_Capability((*[]pkg2_api.Capability)(yyv994), d)
				}
			}
		case "volumes":
			if r.TryDecodeAsNil() {
				x.Volumes = nil
			} else {
				yyv996 := &x.Volumes
				yym997 := z.DecBinary()
				_ = yym997
				if false {
				} else {
					h.decSliceFSType((*[]FSType)(yyv996), d)
				}
			}
		case "hostNetwork":
			if r.TryDecodeAsNil() {
				x.HostNetwork = false
			} else {
				x.HostNetwork = bool(r.DecodeBool())
			}
		case "hostPorts":
			if r.TryDecodeAsNil() {
				x.HostPorts = nil
			} else {
				yyv999 := &x.HostPorts
				yym1000 := z.DecBinary()
				_ = yym1000
				if false {
				} else {
					h.decSliceHostPortRange((*[]HostPortRange)(yyv999), d)
				}
			}
		case "hostPID":
			if r.TryDecodeAsNil() {
				x.HostPID = false
			} else {
				x.HostPID = bool(r.DecodeBool())
			}
		case "hostIPC":
			if r.TryDecodeAsNil() {
				x.HostIPC = false
			} else {
				x.HostIPC = bool(r.DecodeBool())
			}
		case "seLinux":
			if r.TryDecodeAsNil() {
				x.SELinux = SELinuxStrategyOptions{}
			} else {
				yyv1003 := &x.SELinux
				yyv1003.CodecDecodeSelf(d)
			}
		case "runAsUser":
			if r.TryDecodeAsNil() {
				x.RunAsUser = RunAsUserStrategyOptions{}
			} else {
				yyv1004 := &x.RunAsUser
				yyv1004.CodecDecodeSelf(d)
			}
		case "supplementalGroups":
			if r.TryDecodeAsNil() {
				x.SupplementalGroups = SupplementalGroupsStrategyOptions{}
			} else {
				yyv1005 := &x.SupplementalGroups
				yyv1005.CodecDecodeSelf(d)
			}
		case "fsGroup":
			if r.TryDecodeAsNil() {
				x.FSGroup = FSGroupStrategyOptions{}
			} else {
				yyv1006 := &x.FSGroup
				yyv1006.CodecDecodeSelf(d)
			}
		case "readOnlyRootFilesystem":
			if r.TryDecodeAsNil() {
				x.ReadOnlyRootFilesystem = false
			} else {
				x.ReadOnlyRootFilesystem = bool(r.DecodeBool())
			}
		default:
			z.DecStructFieldNotFound(-1, yys988)
		} // end switch yys988
	} // end for yyj988
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *PodSecurityPolicySpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj1008 int
	var yyb1008 bool
	var yyhl1008 bool = l >= 0
	yyj1008++
	if yyhl1008 {
		yyb1008 = yyj1008 > l
	} else {
		yyb1008 = r.CheckBreak()
	}
	if yyb1008 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Privileged = false
	} else {
		x.Privileged = bool(r.DecodeBool())
	}
	yyj1008++
	if yyhl1008 {
		yyb1008 = yyj1008 > l
	} else {
		yyb1008 = r.CheckBreak()
	}
	if yyb1008 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.DefaultAddCapabilities = nil
	} else {
		yyv1010 := &x.DefaultAddCapabilities
		yym1011 := z.DecBinary()
		_ = yym1011
		if false {
		} else {
			h.decSliceapi_Capability((*[]pkg2_api.Capability)(yyv1010), d)
		}
	}
	yyj1008++
	if yyhl1008 {
		yyb1008 = yyj1008 > l
	} else {
		yyb1008 = r.CheckBreak()
	}
	if yyb1008 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.RequiredDropCapabilities = nil
	} else {
		yyv1012 := &x.RequiredDropCapabilities
		yym1013 := z.DecBinary()
		_ = yym1013
		if false {
		} else {
			h.decSliceapi_Capability((*[]pkg2_api.Capability)(yyv1012), d)
		}
	}
	yyj1008++
	if yyhl1008 {
		yyb1008 = yyj1008 > l
	} else {
		yyb1008 = r.CheckBreak()
	}
	if yyb1008 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.AllowedCapabilities = nil
	} else {
		yyv1014 := &x.AllowedCapabilities
		yym1015 := z.DecBinary()
		_ = yym1015
		if false {
		} else {
			h.decSliceapi_Capability((*[]pkg2_api.Capability)(yyv1014), d)
		}
	}
	yyj1008++
	if yyhl1008 {
		yyb1008 = yyj1008 > l
	} else {
		yyb1008 = r.CheckBreak()
	}
	if yyb1008 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Volumes = nil
	} else {
		yyv1016 := &x.Volumes
		yym1017 := z.DecBinary()
		_ = yym1017
		if false {
		} else {
			h.decSliceFSType((*[]FSType)(yyv1016), d)
		}
	}
	yyj1008++
	if yyhl1008 {
		yyb1008 = yyj1008 > l
	} else {
		yyb1008 = r.CheckBreak()
	}
	if yyb1008 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.HostNetwork = false
	} else {
		x.HostNetwork = bool(r.DecodeBool())
	}
	yyj1008++
	if yyhl1008 {
		yyb1008 = yyj1008 > l
	} else {
		yyb1008 = r.CheckBreak()
	}
	if yyb1008 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.HostPorts = nil
	} else {
		yyv1019 := &x.HostPorts
		yym1020 := z.DecBinary()
		_ = yym1020
		if false {
		} else {
			h.decSliceHostPortRange((*[]HostPortRange)(yyv1019), d)
		}
	}
	yyj1008++
	if yyhl1008 {
		yyb1008 = yyj1008 > l
	} else {
		yyb1008 = r.CheckBreak()
	}
	if yyb1008 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.HostPID = false
	} else {
		x.HostPID = bool(r.DecodeBool())
	}
	yyj1008++
	if yyhl1008 {
		yyb1008 = yyj1008 > l
	} else {
		yyb1008 = r.CheckBreak()
	}
	if yyb1008 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.HostIPC = false
	} else {
		x.HostIPC = bool(r.DecodeBool())
	}
	yyj1008++
	if yyhl1008 {
		yyb1008 = yyj1008 > l
	} else {
		yyb1008 = r.CheckBreak()
	}
	if yyb1008 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.SELinux = SELinuxStrategyOptions{}
	} else {
		yyv1023 := &x.SELinux
		yyv1023.CodecDecodeSelf(d)
	}
	yyj1008++
	if yyhl1008 {
		yyb1008 = yyj1008 > l
	} else {
		yyb1008 = r.CheckBreak()
	}
	if yyb1008 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.RunAsUser = RunAsUserStrategyOptions{}
	} else {
		yyv1024 := &x.RunAsUser
		yyv1024.CodecDecodeSelf(d)
	}
	yyj1008++
	if yyhl1008 {
		yyb1008 = yyj1008 > l
	} else {
		yyb1008 = r.CheckBreak()
	}
	if yyb1008 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.SupplementalGroups = SupplementalGroupsStrategyOptions{}
	} else {
		yyv1025 := &x.SupplementalGroups
		yyv1025.CodecDecodeSelf(d)
	}
	yyj1008++
	if yyhl1008 {
		yyb1008 = yyj1008 > l
	} else {
		yyb1008 = r.CheckBreak()
	}
	if yyb1008 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.FSGroup = FSGroupStrategyOptions{}
	} else {
		yyv1026 := &x.FSGroup
		yyv1026.CodecDecodeSelf(d)
	}
	yyj1008++
	if yyhl1008 {
		yyb1008 = yyj1008 > l
	} else {
		yyb1008 = r.CheckBreak()
	}
	if yyb1008 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ReadOnlyRootFilesystem = false
	} else {
		x.ReadOnlyRootFilesystem = bool(r.DecodeBool())
	}
	for {
		yyj1008++
		if yyhl1008 {
			yyb1008 = yyj1008 > l
		} else {
			yyb1008 = r.CheckBreak()
		}
		if yyb1008 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1008-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *HostPortRange) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym1028 := z.EncBinary()
		_ = yym1028
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1029 := !z.EncBinary()
			yy2arr1029 := z.EncBasicHandle().StructToArray
			var yyq1029 [2]bool
			_, _, _ = yysep1029, yyq1029, yy2arr1029
			const yyr1029 bool = false
			var yynn1029 int
			if yyr1029 || yy2arr1029 {
				r.EncodeArrayStart(2)
			} else {
				yynn1029 = 2
				for _, b := range yyq1029 {
					if b {
						yynn1029++
					}
				}
				r.EncodeMapStart(yynn1029)
				yynn1029 = 0
			}
			if yyr1029 || yy2arr1029 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym1031 := z.EncBinary()
				_ = yym1031
				if false {
				} else {
					r.EncodeInt(int64(x.Min))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("min"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yym1032 := z.EncBinary()
				_ = yym1032
				if false {
				} else {
					r.EncodeInt(int64(x.Min))
				}
			}
			if yyr1029 || yy2arr1029 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym1034 := z.EncBinary()
				_ = yym1034
				if false {
				} else {
					r.EncodeInt(int64(x.Max))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("max"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yym1035 := z.EncBinary()
				_ = yym1035
				if false {
				} else {
					r.EncodeInt(int64(x.Max))
				}
			}
			if yyr1029 || yy2arr1029 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *HostPortRange) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym1036 := z.DecBinary()
	_ = yym1036
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1037 := r.ContainerType()
		if yyct1037 == codecSelferValueTypeMap1234 {
			yyl1037 := r.ReadMapStart()
			if yyl1037 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1037, d)
			}
		} else if yyct1037 == codecSelferValueTypeArray1234 {
			yyl1037 := r.ReadArrayStart()
			if yyl1037 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1037, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *HostPortRange) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys1038Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1038Slc
	var yyhl1038 bool = l >= 0
	for yyj1038 := 0; ; yyj1038++ {
		if yyhl1038 {
			if yyj1038 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1038Slc = r.DecodeBytes(yys1038Slc, true, true)
		yys1038 := string(yys1038Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1038 {
		case "min":
			if r.TryDecodeAsNil() {
				x.Min = 0
			} else {
				x.Min = int(r.DecodeInt(codecSelferBitsize1234))
			}
		case "max":
			if r.TryDecodeAsNil() {
				x.Max = 0
			} else {
				x.Max = int(r.DecodeInt(codecSelferBitsize1234))
			}
		default:
			z.DecStructFieldNotFound(-1, yys1038)
		} // end switch yys1038
	} // end for yyj1038
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *HostPortRange) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj1041 int
	var yyb1041 bool
	var yyhl1041 bool = l >= 0
	yyj1041++
	if yyhl1041 {
		yyb1041 = yyj1041 > l
	} else {
		yyb1041 = r.CheckBreak()
	}
	if yyb1041 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Min = 0
	} else {
		x.Min = int(r.DecodeInt(codecSelferBitsize1234))
	}
	yyj1041++
	if yyhl1041 {
		yyb1041 = yyj1041 > l
	} else {
		yyb1041 = r.CheckBreak()
	}
	if yyb1041 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Max = 0
	} else {
		x.Max = int(r.DecodeInt(codecSelferBitsize1234))
	}
	for {
		yyj1041++
		if yyhl1041 {
			yyb1041 = yyj1041 > l
		} else {
			yyb1041 = r.CheckBreak()
		}
		if yyb1041 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1041-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x FSType) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	yym1044 := z.EncBinary()
	_ = yym1044
	if false {
	} else if z.HasExtensions() && z.EncExt(x) {
	} else {
		r.EncodeString(codecSelferC_UTF81234, string(x))
	}
}

func (x *FSType) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym1045 := z.DecBinary()
	_ = yym1045
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		*((*string)(x)) = r.DecodeString()
	}
}

func (x *SELinuxStrategyOptions) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym1046 := z.EncBinary()
		_ = yym1046
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1047 := !z.EncBinary()
			yy2arr1047 := z.EncBasicHandle().StructToArray
			var yyq1047 [2]bool
			_, _, _ = yysep1047, yyq1047, yy2arr1047
			const yyr1047 bool = false
			yyq1047[1] = x.SELinuxOptions != nil
			var yynn1047 int
			if yyr1047 || yy2arr1047 {
				r.EncodeArrayStart(2)
			} else {
				yynn1047 = 1
				for _, b := range yyq1047 {
					if b {
						yynn1047++
					}
				}
				r.EncodeMapStart(yynn1047)
				yynn1047 = 0
			}
			if yyr1047 || yy2arr1047 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				x.Rule.CodecEncodeSelf(e)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("rule"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				x.Rule.CodecEncodeSelf(e)
			}
			if yyr1047 || yy2arr1047 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1047[1] {
					if x.SELinuxOptions == nil {
						r.EncodeNil()
					} else {
						x.SELinuxOptions.CodecEncodeSelf(e)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1047[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("seLinuxOptions"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.SELinuxOptions == nil {
						r.EncodeNil()
					} else {
						x.SELinuxOptions.CodecEncodeSelf(e)
					}
				}
			}
			if yyr1047 || yy2arr1047 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *SELinuxStrategyOptions) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym1050 := z.DecBinary()
	_ = yym1050
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1051 := r.ContainerType()
		if yyct1051 == codecSelferValueTypeMap1234 {
			yyl1051 := r.ReadMapStart()
			if yyl1051 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1051, d)
			}
		} else if yyct1051 == codecSelferValueTypeArray1234 {
			yyl1051 := r.ReadArrayStart()
			if yyl1051 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1051, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *SELinuxStrategyOptions) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys1052Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1052Slc
	var yyhl1052 bool = l >= 0
	for yyj1052 := 0; ; yyj1052++ {
		if yyhl1052 {
			if yyj1052 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1052Slc = r.DecodeBytes(yys1052Slc, true, true)
		yys1052 := string(yys1052Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1052 {
		case "rule":
			if r.TryDecodeAsNil() {
				x.Rule = ""
			} else {
				x.Rule = SELinuxStrategy(r.DecodeString())
			}
		case "seLinuxOptions":
			if r.TryDecodeAsNil() {
				if x.SELinuxOptions != nil {
					x.SELinuxOptions = nil
				}
			} else {
				if x.SELinuxOptions == nil {
					x.SELinuxOptions = new(pkg2_api.SELinuxOptions)
				}
				x.SELinuxOptions.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys1052)
		} // end switch yys1052
	} // end for yyj1052
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *SELinuxStrategyOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj1055 int
	var yyb1055 bool
	var yyhl1055 bool = l >= 0
	yyj1055++
	if yyhl1055 {
		yyb1055 = yyj1055 > l
	} else {
		yyb1055 = r.CheckBreak()
	}
	if yyb1055 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Rule = ""
	} else {
		x.Rule = SELinuxStrategy(r.DecodeString())
	}
	yyj1055++
	if yyhl1055 {
		yyb1055 = yyj1055 > l
	} else {
		yyb1055 = r.CheckBreak()
	}
	if yyb1055 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		if x.SELinuxOptions != nil {
			x.SELinuxOptions = nil
		}
	} else {
		if x.SELinuxOptions == nil {
			x.SELinuxOptions = new(pkg2_api.SELinuxOptions)
		}
		x.SELinuxOptions.CodecDecodeSelf(d)
	}
	for {
		yyj1055++
		if yyhl1055 {
			yyb1055 = yyj1055 > l
		} else {
			yyb1055 = r.CheckBreak()
		}
		if yyb1055 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1055-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x SELinuxStrategy) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	yym1058 := z.EncBinary()
	_ = yym1058
	if false {
	} else if z.HasExtensions() && z.EncExt(x) {
	} else {
		r.EncodeString(codecSelferC_UTF81234, string(x))
	}
}

func (x *SELinuxStrategy) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym1059 := z.DecBinary()
	_ = yym1059
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		*((*string)(x)) = r.DecodeString()
	}
}

func (x *RunAsUserStrategyOptions) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym1060 := z.EncBinary()
		_ = yym1060
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1061 := !z.EncBinary()
			yy2arr1061 := z.EncBasicHandle().StructToArray
			var yyq1061 [2]bool
			_, _, _ = yysep1061, yyq1061, yy2arr1061
			const yyr1061 bool = false
			yyq1061[1] = len(x.Ranges) != 0
			var yynn1061 int
			if yyr1061 || yy2arr1061 {
				r.EncodeArrayStart(2)
			} else {
				yynn1061 = 1
				for _, b := range yyq1061 {
					if b {
						yynn1061++
					}
				}
				r.EncodeMapStart(yynn1061)
				yynn1061 = 0
			}
			if yyr1061 || yy2arr1061 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				x.Rule.CodecEncodeSelf(e)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("rule"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				x.Rule.CodecEncodeSelf(e)
			}
			if yyr1061 || yy2arr1061 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1061[1] {
					if x.Ranges == nil {
						r.EncodeNil()
					} else {
						yym1064 := z.EncBinary()
						_ = yym1064
						if false {
						} else {
							h.encSliceIDRange(([]IDRange)(x.Ranges), e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1061[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("ranges"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.Ranges == nil {
						r.EncodeNil()
					} else {
						yym1065 := z.EncBinary()
						_ = yym1065
						if false {
						} else {
							h.encSliceIDRange(([]IDRange)(x.Ranges), e)
						}
					}
				}
			}
			if yyr1061 || yy2arr1061 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *RunAsUserStrategyOptions) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym1066 := z.DecBinary()
	_ = yym1066
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1067 := r.ContainerType()
		if yyct1067 == codecSelferValueTypeMap1234 {
			yyl1067 := r.ReadMapStart()
			if yyl1067 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1067, d)
			}
		} else if yyct1067 == codecSelferValueTypeArray1234 {
			yyl1067 := r.ReadArrayStart()
			if yyl1067 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1067, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *RunAsUserStrategyOptions) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys1068Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1068Slc
	var yyhl1068 bool = l >= 0
	for yyj1068 := 0; ; yyj1068++ {
		if yyhl1068 {
			if yyj1068 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1068Slc = r.DecodeBytes(yys1068Slc, true, true)
		yys1068 := string(yys1068Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1068 {
		case "rule":
			if r.TryDecodeAsNil() {
				x.Rule = ""
			} else {
				x.Rule = RunAsUserStrategy(r.DecodeString())
			}
		case "ranges":
			if r.TryDecodeAsNil() {
				x.Ranges = nil
			} else {
				yyv1070 := &x.Ranges
				yym1071 := z.DecBinary()
				_ = yym1071
				if false {
				} else {
					h.decSliceIDRange((*[]IDRange)(yyv1070), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys1068)
		} // end switch yys1068
	} // end for yyj1068
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *RunAsUserStrategyOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj1072 int
	var yyb1072 bool
	var yyhl1072 bool = l >= 0
	yyj1072++
	if yyhl1072 {
		yyb1072 = yyj1072 > l
	} else {
		yyb1072 = r.CheckBreak()
	}
	if yyb1072 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Rule = ""
	} else {
		x.Rule = RunAsUserStrategy(r.DecodeString())
	}
	yyj1072++
	if yyhl1072 {
		yyb1072 = yyj1072 > l
	} else {
		yyb1072 = r.CheckBreak()
	}
	if yyb1072 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Ranges = nil
	} else {
		yyv1074 := &x.Ranges
		yym1075 := z.DecBinary()
		_ = yym1075
		if false {
		} else {
			h.decSliceIDRange((*[]IDRange)(yyv1074), d)
		}
	}
	for {
		yyj1072++
		if yyhl1072 {
			yyb1072 = yyj1072 > l
		} else {
			yyb1072 = r.CheckBreak()
		}
		if yyb1072 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1072-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *IDRange) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym1076 := z.EncBinary()
		_ = yym1076
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1077 := !z.EncBinary()
			yy2arr1077 := z.EncBasicHandle().StructToArray
			var yyq1077 [2]bool
			_, _, _ = yysep1077, yyq1077, yy2arr1077
			const yyr1077 bool = false
			var yynn1077 int
			if yyr1077 || yy2arr1077 {
				r.EncodeArrayStart(2)
			} else {
				yynn1077 = 2
				for _, b := range yyq1077 {
					if b {
						yynn1077++
					}
				}
				r.EncodeMapStart(yynn1077)
				yynn1077 = 0
			}
			if yyr1077 || yy2arr1077 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym1079 := z.EncBinary()
				_ = yym1079
				if false {
				} else {
					r.EncodeInt(int64(x.Min))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("min"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yym1080 := z.EncBinary()
				_ = yym1080
				if false {
				} else {
					r.EncodeInt(int64(x.Min))
				}
			}
			if yyr1077 || yy2arr1077 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym1082 := z.EncBinary()
				_ = yym1082
				if false {
				} else {
					r.EncodeInt(int64(x.Max))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("max"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yym1083 := z.EncBinary()
				_ = yym1083
				if false {
				} else {
					r.EncodeInt(int64(x.Max))
				}
			}
			if yyr1077 || yy2arr1077 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *IDRange) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym1084 := z.DecBinary()
	_ = yym1084
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1085 := r.ContainerType()
		if yyct1085 == codecSelferValueTypeMap1234 {
			yyl1085 := r.ReadMapStart()
			if yyl1085 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1085, d)
			}
		} else if yyct1085 == codecSelferValueTypeArray1234 {
			yyl1085 := r.ReadArrayStart()
			if yyl1085 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1085, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *IDRange) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys1086Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1086Slc
	var yyhl1086 bool = l >= 0
	for yyj1086 := 0; ; yyj1086++ {
		if yyhl1086 {
			if yyj1086 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1086Slc = r.DecodeBytes(yys1086Slc, true, true)
		yys1086 := string(yys1086Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1086 {
		case "min":
			if r.TryDecodeAsNil() {
				x.Min = 0
			} else {
				x.Min = int64(r.DecodeInt(64))
			}
		case "max":
			if r.TryDecodeAsNil() {
				x.Max = 0
			} else {
				x.Max = int64(r.DecodeInt(64))
			}
		default:
			z.DecStructFieldNotFound(-1, yys1086)
		} // end switch yys1086
	} // end for yyj1086
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *IDRange) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj1089 int
	var yyb1089 bool
	var yyhl1089 bool = l >= 0
	yyj1089++
	if yyhl1089 {
		yyb1089 = yyj1089 > l
	} else {
		yyb1089 = r.CheckBreak()
	}
	if yyb1089 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Min = 0
	} else {
		x.Min = int64(r.DecodeInt(64))
	}
	yyj1089++
	if yyhl1089 {
		yyb1089 = yyj1089 > l
	} else {
		yyb1089 = r.CheckBreak()
	}
	if yyb1089 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Max = 0
	} else {
		x.Max = int64(r.DecodeInt(64))
	}
	for {
		yyj1089++
		if yyhl1089 {
			yyb1089 = yyj1089 > l
		} else {
			yyb1089 = r.CheckBreak()
		}
		if yyb1089 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1089-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x RunAsUserStrategy) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	yym1092 := z.EncBinary()
	_ = yym1092
	if false {
	} else if z.HasExtensions() && z.EncExt(x) {
	} else {
		r.EncodeString(codecSelferC_UTF81234, string(x))
	}
}

func (x *RunAsUserStrategy) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym1093 := z.DecBinary()
	_ = yym1093
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		*((*string)(x)) = r.DecodeString()
	}
}

func (x *FSGroupStrategyOptions) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym1094 := z.EncBinary()
		_ = yym1094
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1095 := !z.EncBinary()
			yy2arr1095 := z.EncBasicHandle().StructToArray
			var yyq1095 [2]bool
			_, _, _ = yysep1095, yyq1095, yy2arr1095
			const yyr1095 bool = false
			yyq1095[0] = x.Rule != ""
			yyq1095[1] = len(x.Ranges) != 0
			var yynn1095 int
			if yyr1095 || yy2arr1095 {
				r.EncodeArrayStart(2)
			} else {
				yynn1095 = 0
				for _, b := range yyq1095 {
					if b {
						yynn1095++
					}
				}
				r.EncodeMapStart(yynn1095)
				yynn1095 = 0
			}
			if yyr1095 || yy2arr1095 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1095[0] {
					x.Rule.CodecEncodeSelf(e)
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1095[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("rule"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					x.Rule.CodecEncodeSelf(e)
				}
			}
			if yyr1095 || yy2arr1095 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1095[1] {
					if x.Ranges == nil {
						r.EncodeNil()
					} else {
						yym1098 := z.EncBinary()
						_ = yym1098
						if false {
						} else {
							h.encSliceIDRange(([]IDRange)(x.Ranges), e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1095[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("ranges"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.Ranges == nil {
						r.EncodeNil()
					} else {
						yym1099 := z.EncBinary()
						_ = yym1099
						if false {
						} else {
							h.encSliceIDRange(([]IDRange)(x.Ranges), e)
						}
					}
				}
			}
			if yyr1095 || yy2arr1095 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *FSGroupStrategyOptions) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym1100 := z.DecBinary()
	_ = yym1100
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1101 := r.ContainerType()
		if yyct1101 == codecSelferValueTypeMap1234 {
			yyl1101 := r.ReadMapStart()
			if yyl1101 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1101, d)
			}
		} else if yyct1101 == codecSelferValueTypeArray1234 {
			yyl1101 := r.ReadArrayStart()
			if yyl1101 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1101, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *FSGroupStrategyOptions) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys1102Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1102Slc
	var yyhl1102 bool = l >= 0
	for yyj1102 := 0; ; yyj1102++ {
		if yyhl1102 {
			if yyj1102 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1102Slc = r.DecodeBytes(yys1102Slc, true, true)
		yys1102 := string(yys1102Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1102 {
		case "rule":
			if r.TryDecodeAsNil() {
				x.Rule = ""
			} else {
				x.Rule = FSGroupStrategyType(r.DecodeString())
			}
		case "ranges":
			if r.TryDecodeAsNil() {
				x.Ranges = nil
			} else {
				yyv1104 := &x.Ranges
				yym1105 := z.DecBinary()
				_ = yym1105
				if false {
				} else {
					h.decSliceIDRange((*[]IDRange)(yyv1104), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys1102)
		} // end switch yys1102
	} // end for yyj1102
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *FSGroupStrategyOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj1106 int
	var yyb1106 bool
	var yyhl1106 bool = l >= 0
	yyj1106++
	if yyhl1106 {
		yyb1106 = yyj1106 > l
	} else {
		yyb1106 = r.CheckBreak()
	}
	if yyb1106 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Rule = ""
	} else {
		x.Rule = FSGroupStrategyType(r.DecodeString())
	}
	yyj1106++
	if yyhl1106 {
		yyb1106 = yyj1106 > l
	} else {
		yyb1106 = r.CheckBreak()
	}
	if yyb1106 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Ranges = nil
	} else {
		yyv1108 := &x.Ranges
		yym1109 := z.DecBinary()
		_ = yym1109
		if false {
		} else {
			h.decSliceIDRange((*[]IDRange)(yyv1108), d)
		}
	}
	for {
		yyj1106++
		if yyhl1106 {
			yyb1106 = yyj1106 > l
		} else {
			yyb1106 = r.CheckBreak()
		}
		if yyb1106 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1106-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x FSGroupStrategyType) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	yym1110 := z.EncBinary()
	_ = yym1110
	if false {
	} else if z.HasExtensions() && z.EncExt(x) {
	} else {
		r.EncodeString(codecSelferC_UTF81234, string(x))
	}
}

func (x *FSGroupStrategyType) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym1111 := z.DecBinary()
	_ = yym1111
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		*((*string)(x)) = r.DecodeString()
	}
}

func (x *SupplementalGroupsStrategyOptions) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym1112 := z.EncBinary()
		_ = yym1112
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1113 := !z.EncBinary()
			yy2arr1113 := z.EncBasicHandle().StructToArray
			var yyq1113 [2]bool
			_, _, _ = yysep1113, yyq1113, yy2arr1113
			const yyr1113 bool = false
			yyq1113[0] = x.Rule != ""
			yyq1113[1] = len(x.Ranges) != 0
			var yynn1113 int
			if yyr1113 || yy2arr1113 {
				r.EncodeArrayStart(2)
			} else {
				yynn1113 = 0
				for _, b := range yyq1113 {
					if b {
						yynn1113++
					}
				}
				r.EncodeMapStart(yynn1113)
				yynn1113 = 0
			}
			if yyr1113 || yy2arr1113 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1113[0] {
					x.Rule.CodecEncodeSelf(e)
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1113[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("rule"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					x.Rule.CodecEncodeSelf(e)
				}
			}
			if yyr1113 || yy2arr1113 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1113[1] {
					if x.Ranges == nil {
						r.EncodeNil()
					} else {
						yym1116 := z.EncBinary()
						_ = yym1116
						if false {
						} else {
							h.encSliceIDRange(([]IDRange)(x.Ranges), e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1113[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("ranges"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.Ranges == nil {
						r.EncodeNil()
					} else {
						yym1117 := z.EncBinary()
						_ = yym1117
						if false {
						} else {
							h.encSliceIDRange(([]IDRange)(x.Ranges), e)
						}
					}
				}
			}
			if yyr1113 || yy2arr1113 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *SupplementalGroupsStrategyOptions) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym1118 := z.DecBinary()
	_ = yym1118
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1119 := r.ContainerType()
		if yyct1119 == codecSelferValueTypeMap1234 {
			yyl1119 := r.ReadMapStart()
			if yyl1119 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1119, d)
			}
		} else if yyct1119 == codecSelferValueTypeArray1234 {
			yyl1119 := r.ReadArrayStart()
			if yyl1119 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1119, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *SupplementalGroupsStrategyOptions) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys1120Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1120Slc
	var yyhl1120 bool = l >= 0
	for yyj1120 := 0; ; yyj1120++ {
		if yyhl1120 {
			if yyj1120 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1120Slc = r.DecodeBytes(yys1120Slc, true, true)
		yys1120 := string(yys1120Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1120 {
		case "rule":
			if r.TryDecodeAsNil() {
				x.Rule = ""
			} else {
				x.Rule = SupplementalGroupsStrategyType(r.DecodeString())
			}
		case "ranges":
			if r.TryDecodeAsNil() {
				x.Ranges = nil
			} else {
				yyv1122 := &x.Ranges
				yym1123 := z.DecBinary()
				_ = yym1123
				if false {
				} else {
					h.decSliceIDRange((*[]IDRange)(yyv1122), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys1120)
		} // end switch yys1120
	} // end for yyj1120
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *SupplementalGroupsStrategyOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj1124 int
	var yyb1124 bool
	var yyhl1124 bool = l >= 0
	yyj1124++
	if yyhl1124 {
		yyb1124 = yyj1124 > l
	} else {
		yyb1124 = r.CheckBreak()
	}
	if yyb1124 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Rule = ""
	} else {
		x.Rule = SupplementalGroupsStrategyType(r.DecodeString())
	}
	yyj1124++
	if yyhl1124 {
		yyb1124 = yyj1124 > l
	} else {
		yyb1124 = r.CheckBreak()
	}
	if yyb1124 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Ranges = nil
	} else {
		yyv1126 := &x.Ranges
		yym1127 := z.DecBinary()
		_ = yym1127
		if false {
		} else {
			h.decSliceIDRange((*[]IDRange)(yyv1126), d)
		}
	}
	for {
		yyj1124++
		if yyhl1124 {
			yyb1124 = yyj1124 > l
		} else {
			yyb1124 = r.CheckBreak()
		}
		if yyb1124 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1124-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x SupplementalGroupsStrategyType) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	yym1128 := z.EncBinary()
	_ = yym1128
	if false {
	} else if z.HasExtensions() && z.EncExt(x) {
	} else {
		r.EncodeString(codecSelferC_UTF81234, string(x))
	}
}

func (x *SupplementalGroupsStrategyType) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym1129 := z.DecBinary()
	_ = yym1129
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		*((*string)(x)) = r.DecodeString()
	}
}

func (x *PodSecurityPolicyList) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym1130 := z.EncBinary()
		_ = yym1130
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1131 := !z.EncBinary()
			yy2arr1131 := z.EncBasicHandle().StructToArray
			var yyq1131 [4]bool
			_, _, _ = yysep1131, yyq1131, yy2arr1131
			const yyr1131 bool = false
			yyq1131[0] = x.Kind != ""
			yyq1131[1] = x.APIVersion != ""
			yyq1131[2] = true
			var yynn1131 int
			if yyr1131 || yy2arr1131 {
				r.EncodeArrayStart(4)
			} else {
				yynn1131 = 1
				for _, b := range yyq1131 {
					if b {
						yynn1131++
					}
				}
				r.EncodeMapStart(yynn1131)
				yynn1131 = 0
			}
			if yyr1131 || yy2arr1131 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1131[0] {
					yym1133 := z.EncBinary()
					_ = yym1133
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1131[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1134 := z.EncBinary()
					_ = yym1134
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr1131 || yy2arr1131 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1131[1] {
					yym1136 := z.EncBinary()
					_ = yym1136
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1131[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1137 := z.EncBinary()
					_ = yym1137
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr1131 || yy2arr1131 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1131[2] {
					yy1139 := &x.ListMeta
					yym1140 := z.EncBinary()
					_ = yym1140
					if false {
					} else if z.HasExtensions() && z.EncExt(yy1139) {
					} else {
						z.EncFallback(yy1139)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1131[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy1141 := &x.ListMeta
					yym1142 := z.EncBinary()
					_ = yym1142
					if false {
					} else if z.HasExtensions() && z.EncExt(yy1141) {
					} else {
						z.EncFallback(yy1141)
					}
				}
			}
			if yyr1131 || yy2arr1131 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym1144 := z.EncBinary()
					_ = yym1144
					if false {
					} else {
						h.encSlicePodSecurityPolicy(([]PodSecurityPolicy)(x.Items), e)
					}
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("items"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym1145 := z.EncBinary()
					_ = yym1145
					if false {
					} else {
						h.encSlicePodSecurityPolicy(([]PodSecurityPolicy)(x.Items), e)
					}
				}
			}
			if yyr1131 || yy2arr1131 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *PodSecurityPolicyList) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym1146 := z.DecBinary()
	_ = yym1146
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1147 := r.ContainerType()
		if yyct1147 == codecSelferValueTypeMap1234 {
			yyl1147 := r.ReadMapStart()
			if yyl1147 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1147, d)
			}
		} else if yyct1147 == codecSelferValueTypeArray1234 {
			yyl1147 := r.ReadArrayStart()
			if yyl1147 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1147, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *PodSecurityPolicyList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys1148Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1148Slc
	var yyhl1148 bool = l >= 0
	for yyj1148 := 0; ; yyj1148++ {
		if yyhl1148 {
			if yyj1148 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1148Slc = r.DecodeBytes(yys1148Slc, true, true)
		yys1148 := string(yys1148Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1148 {
		case "kind":
			if r.TryDecodeAsNil() {
				x.Kind = ""
			} else {
				x.Kind = string(r.DecodeString())
			}
		case "apiVersion":
			if r.TryDecodeAsNil() {
				x.APIVersion = ""
			} else {
				x.APIVersion = string(r.DecodeString())
			}
		case "metadata":
			if r.TryDecodeAsNil() {
				x.ListMeta = pkg1_unversioned.ListMeta{}
			} else {
				yyv1151 := &x.ListMeta
				yym1152 := z.DecBinary()
				_ = yym1152
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv1151) {
				} else {
					z.DecFallback(yyv1151, false)
				}
			}
		case "items":
			if r.TryDecodeAsNil() {
				x.Items = nil
			} else {
				yyv1153 := &x.Items
				yym1154 := z.DecBinary()
				_ = yym1154
				if false {
				} else {
					h.decSlicePodSecurityPolicy((*[]PodSecurityPolicy)(yyv1153), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys1148)
		} // end switch yys1148
	} // end for yyj1148
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *PodSecurityPolicyList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj1155 int
	var yyb1155 bool
	var yyhl1155 bool = l >= 0
	yyj1155++
	if yyhl1155 {
		yyb1155 = yyj1155 > l
	} else {
		yyb1155 = r.CheckBreak()
	}
	if yyb1155 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj1155++
	if yyhl1155 {
		yyb1155 = yyj1155 > l
	} else {
		yyb1155 = r.CheckBreak()
	}
	if yyb1155 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj1155++
	if yyhl1155 {
		yyb1155 = yyj1155 > l
	} else {
		yyb1155 = r.CheckBreak()
	}
	if yyb1155 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ListMeta = pkg1_unversioned.ListMeta{}
	} else {
		yyv1158 := &x.ListMeta
		yym1159 := z.DecBinary()
		_ = yym1159
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv1158) {
		} else {
			z.DecFallback(yyv1158, false)
		}
	}
	yyj1155++
	if yyhl1155 {
		yyb1155 = yyj1155 > l
	} else {
		yyb1155 = r.CheckBreak()
	}
	if yyb1155 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Items = nil
	} else {
		yyv1160 := &x.Items
		yym1161 := z.DecBinary()
		_ = yym1161
		if false {
		} else {
			h.decSlicePodSecurityPolicy((*[]PodSecurityPolicy)(yyv1160), d)
		}
	}
	for {
		yyj1155++
		if yyhl1155 {
			yyb1155 = yyj1155 > l
		} else {
			yyb1155 = r.CheckBreak()
		}
		if yyb1155 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1155-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *NetworkPolicy) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym1162 := z.EncBinary()
		_ = yym1162
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1163 := !z.EncBinary()
			yy2arr1163 := z.EncBasicHandle().StructToArray
			var yyq1163 [4]bool
			_, _, _ = yysep1163, yyq1163, yy2arr1163
			const yyr1163 bool = false
			yyq1163[0] = x.Kind != ""
			yyq1163[1] = x.APIVersion != ""
			yyq1163[2] = true
			yyq1163[3] = true
			var yynn1163 int
			if yyr1163 || yy2arr1163 {
				r.EncodeArrayStart(4)
			} else {
				yynn1163 = 0
				for _, b := range yyq1163 {
					if b {
						yynn1163++
					}
				}
				r.EncodeMapStart(yynn1163)
				yynn1163 = 0
			}
			if yyr1163 || yy2arr1163 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1163[0] {
					yym1165 := z.EncBinary()
					_ = yym1165
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1163[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1166 := z.EncBinary()
					_ = yym1166
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr1163 || yy2arr1163 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1163[1] {
					yym1168 := z.EncBinary()
					_ = yym1168
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1163[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1169 := z.EncBinary()
					_ = yym1169
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr1163 || yy2arr1163 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1163[2] {
					yy1171 := &x.ObjectMeta
					yy1171.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1163[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy1172 := &x.ObjectMeta
					yy1172.CodecEncodeSelf(e)
				}
			}
			if yyr1163 || yy2arr1163 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1163[3] {
					yy1174 := &x.Spec
					yy1174.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1163[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("spec"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy1175 := &x.Spec
					yy1175.CodecEncodeSelf(e)
				}
			}
			if yyr1163 || yy2arr1163 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *NetworkPolicy) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym1176 := z.DecBinary()
	_ = yym1176
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1177 := r.ContainerType()
		if yyct1177 == codecSelferValueTypeMap1234 {
			yyl1177 := r.ReadMapStart()
			if yyl1177 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1177, d)
			}
		} else if yyct1177 == codecSelferValueTypeArray1234 {
			yyl1177 := r.ReadArrayStart()
			if yyl1177 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1177, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *NetworkPolicy) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys1178Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1178Slc
	var yyhl1178 bool = l >= 0
	for yyj1178 := 0; ; yyj1178++ {
		if yyhl1178 {
			if yyj1178 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1178Slc = r.DecodeBytes(yys1178Slc, true, true)
		yys1178 := string(yys1178Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1178 {
		case "kind":
			if r.TryDecodeAsNil() {
				x.Kind = ""
			} else {
				x.Kind = string(r.DecodeString())
			}
		case "apiVersion":
			if r.TryDecodeAsNil() {
				x.APIVersion = ""
			} else {
				x.APIVersion = string(r.DecodeString())
			}
		case "metadata":
			if r.TryDecodeAsNil() {
				x.ObjectMeta = pkg2_api.ObjectMeta{}
			} else {
				yyv1181 := &x.ObjectMeta
				yyv1181.CodecDecodeSelf(d)
			}
		case "spec":
			if r.TryDecodeAsNil() {
				x.Spec = NetworkPolicySpec{}
			} else {
				yyv1182 := &x.Spec
				yyv1182.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys1178)
		} // end switch yys1178
	} // end for yyj1178
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *NetworkPolicy) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj1183 int
	var yyb1183 bool
	var yyhl1183 bool = l >= 0
	yyj1183++
	if yyhl1183 {
		yyb1183 = yyj1183 > l
	} else {
		yyb1183 = r.CheckBreak()
	}
	if yyb1183 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj1183++
	if yyhl1183 {
		yyb1183 = yyj1183 > l
	} else {
		yyb1183 = r.CheckBreak()
	}
	if yyb1183 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj1183++
	if yyhl1183 {
		yyb1183 = yyj1183 > l
	} else {
		yyb1183 = r.CheckBreak()
	}
	if yyb1183 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ObjectMeta = pkg2_api.ObjectMeta{}
	} else {
		yyv1186 := &x.ObjectMeta
		yyv1186.CodecDecodeSelf(d)
	}
	yyj1183++
	if yyhl1183 {
		yyb1183 = yyj1183 > l
	} else {
		yyb1183 = r.CheckBreak()
	}
	if yyb1183 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Spec = NetworkPolicySpec{}
	} else {
		yyv1187 := &x.Spec
		yyv1187.CodecDecodeSelf(d)
	}
	for {
		yyj1183++
		if yyhl1183 {
			yyb1183 = yyj1183 > l
		} else {
			yyb1183 = r.CheckBreak()
		}
		if yyb1183 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1183-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *NetworkPolicySpec) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym1188 := z.EncBinary()
		_ = yym1188
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1189 := !z.EncBinary()
			yy2arr1189 := z.EncBasicHandle().StructToArray
			var yyq1189 [2]bool
			_, _, _ = yysep1189, yyq1189, yy2arr1189
			const yyr1189 bool = false
			yyq1189[1] = len(x.Ingress) != 0
			var yynn1189 int
			if yyr1189 || yy2arr1189 {
				r.EncodeArrayStart(2)
			} else {
				yynn1189 = 1
				for _, b := range yyq1189 {
					if b {
						yynn1189++
					}
				}
				r.EncodeMapStart(yynn1189)
				yynn1189 = 0
			}
			if yyr1189 || yy2arr1189 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yy1191 := &x.PodSelector
				yym1192 := z.EncBinary()
				_ = yym1192
				if false {
				} else if z.HasExtensions() && z.EncExt(yy1191) {
				} else {
					z.EncFallback(yy1191)
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("podSelector"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yy1193 := &x.PodSelector
				yym1194 := z.EncBinary()
				_ = yym1194
				if false {
				} else if z.HasExtensions() && z.EncExt(yy1193) {
				} else {
					z.EncFallback(yy1193)
				}
			}
			if yyr1189 || yy2arr1189 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1189[1] {
					if x.Ingress == nil {
						r.EncodeNil()
					} else {
						yym1196 := z.EncBinary()
						_ = yym1196
						if false {
						} else {
							h.encSliceNetworkPolicyIngressRule(([]NetworkPolicyIngressRule)(x.Ingress), e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1189[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("ingress"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.Ingress == nil {
						r.EncodeNil()
					} else {
						yym1197 := z.EncBinary()
						_ = yym1197
						if false {
						} else {
							h.encSliceNetworkPolicyIngressRule(([]NetworkPolicyIngressRule)(x.Ingress), e)
						}
					}
				}
			}
			if yyr1189 || yy2arr1189 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *NetworkPolicySpec) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym1198 := z.DecBinary()
	_ = yym1198
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1199 := r.ContainerType()
		if yyct1199 == codecSelferValueTypeMap1234 {
			yyl1199 := r.ReadMapStart()
			if yyl1199 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1199, d)
			}
		} else if yyct1199 == codecSelferValueTypeArray1234 {
			yyl1199 := r.ReadArrayStart()
			if yyl1199 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1199, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *NetworkPolicySpec) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys1200Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1200Slc
	var yyhl1200 bool = l >= 0
	for yyj1200 := 0; ; yyj1200++ {
		if yyhl1200 {
			if yyj1200 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1200Slc = r.DecodeBytes(yys1200Slc, true, true)
		yys1200 := string(yys1200Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1200 {
		case "podSelector":
			if r.TryDecodeAsNil() {
				x.PodSelector = pkg1_unversioned.LabelSelector{}
			} else {
				yyv1201 := &x.PodSelector
				yym1202 := z.DecBinary()
				_ = yym1202
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv1201) {
				} else {
					z.DecFallback(yyv1201, false)
				}
			}
		case "ingress":
			if r.TryDecodeAsNil() {
				x.Ingress = nil
			} else {
				yyv1203 := &x.Ingress
				yym1204 := z.DecBinary()
				_ = yym1204
				if false {
				} else {
					h.decSliceNetworkPolicyIngressRule((*[]NetworkPolicyIngressRule)(yyv1203), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys1200)
		} // end switch yys1200
	} // end for yyj1200
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *NetworkPolicySpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj1205 int
	var yyb1205 bool
	var yyhl1205 bool = l >= 0
	yyj1205++
	if yyhl1205 {
		yyb1205 = yyj1205 > l
	} else {
		yyb1205 = r.CheckBreak()
	}
	if yyb1205 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.PodSelector = pkg1_unversioned.LabelSelector{}
	} else {
		yyv1206 := &x.PodSelector
		yym1207 := z.DecBinary()
		_ = yym1207
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv1206) {
		} else {
			z.DecFallback(yyv1206, false)
		}
	}
	yyj1205++
	if yyhl1205 {
		yyb1205 = yyj1205 > l
	} else {
		yyb1205 = r.CheckBreak()
	}
	if yyb1205 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Ingress = nil
	} else {
		yyv1208 := &x.Ingress
		yym1209 := z.DecBinary()
		_ = yym1209
		if false {
		} else {
			h.decSliceNetworkPolicyIngressRule((*[]NetworkPolicyIngressRule)(yyv1208), d)
		}
	}
	for {
		yyj1205++
		if yyhl1205 {
			yyb1205 = yyj1205 > l
		} else {
			yyb1205 = r.CheckBreak()
		}
		if yyb1205 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1205-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *NetworkPolicyIngressRule) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym1210 := z.EncBinary()
		_ = yym1210
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1211 := !z.EncBinary()
			yy2arr1211 := z.EncBasicHandle().StructToArray
			var yyq1211 [2]bool
			_, _, _ = yysep1211, yyq1211, yy2arr1211
			const yyr1211 bool = false
			yyq1211[0] = len(x.Ports) != 0
			yyq1211[1] = len(x.From) != 0
			var yynn1211 int
			if yyr1211 || yy2arr1211 {
				r.EncodeArrayStart(2)
			} else {
				yynn1211 = 0
				for _, b := range yyq1211 {
					if b {
						yynn1211++
					}
				}
				r.EncodeMapStart(yynn1211)
				yynn1211 = 0
			}
			if yyr1211 || yy2arr1211 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1211[0] {
					if x.Ports == nil {
						r.EncodeNil()
					} else {
						yym1213 := z.EncBinary()
						_ = yym1213
						if false {
						} else {
							h.encSliceNetworkPolicyPort(([]NetworkPolicyPort)(x.Ports), e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1211[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("ports"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.Ports == nil {
						r.EncodeNil()
					} else {
						yym1214 := z.EncBinary()
						_ = yym1214
						if false {
						} else {
							h.encSliceNetworkPolicyPort(([]NetworkPolicyPort)(x.Ports), e)
						}
					}
				}
			}
			if yyr1211 || yy2arr1211 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1211[1] {
					if x.From == nil {
						r.EncodeNil()
					} else {
						yym1216 := z.EncBinary()
						_ = yym1216
						if false {
						} else {
							h.encSliceNetworkPolicyPeer(([]NetworkPolicyPeer)(x.From), e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1211[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("from"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.From == nil {
						r.EncodeNil()
					} else {
						yym1217 := z.EncBinary()
						_ = yym1217
						if false {
						} else {
							h.encSliceNetworkPolicyPeer(([]NetworkPolicyPeer)(x.From), e)
						}
					}
				}
			}
			if yyr1211 || yy2arr1211 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *NetworkPolicyIngressRule) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym1218 := z.DecBinary()
	_ = yym1218
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1219 := r.ContainerType()
		if yyct1219 == codecSelferValueTypeMap1234 {
			yyl1219 := r.ReadMapStart()
			if yyl1219 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1219, d)
			}
		} else if yyct1219 == codecSelferValueTypeArray1234 {
			yyl1219 := r.ReadArrayStart()
			if yyl1219 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1219, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *NetworkPolicyIngressRule) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys1220Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1220Slc
	var yyhl1220 bool = l >= 0
	for yyj1220 := 0; ; yyj1220++ {
		if yyhl1220 {
			if yyj1220 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1220Slc = r.DecodeBytes(yys1220Slc, true, true)
		yys1220 := string(yys1220Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1220 {
		case "ports":
			if r.TryDecodeAsNil() {
				x.Ports = nil
			} else {
				yyv1221 := &x.Ports
				yym1222 := z.DecBinary()
				_ = yym1222
				if false {
				} else {
					h.decSliceNetworkPolicyPort((*[]NetworkPolicyPort)(yyv1221), d)
				}
			}
		case "from":
			if r.TryDecodeAsNil() {
				x.From = nil
			} else {
				yyv1223 := &x.From
				yym1224 := z.DecBinary()
				_ = yym1224
				if false {
				} else {
					h.decSliceNetworkPolicyPeer((*[]NetworkPolicyPeer)(yyv1223), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys1220)
		} // end switch yys1220
	} // end for yyj1220
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *NetworkPolicyIngressRule) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj1225 int
	var yyb1225 bool
	var yyhl1225 bool = l >= 0
	yyj1225++
	if yyhl1225 {
		yyb1225 = yyj1225 > l
	} else {
		yyb1225 = r.CheckBreak()
	}
	if yyb1225 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Ports = nil
	} else {
		yyv1226 := &x.Ports
		yym1227 := z.DecBinary()
		_ = yym1227
		if false {
		} else {
			h.decSliceNetworkPolicyPort((*[]NetworkPolicyPort)(yyv1226), d)
		}
	}
	yyj1225++
	if yyhl1225 {
		yyb1225 = yyj1225 > l
	} else {
		yyb1225 = r.CheckBreak()
	}
	if yyb1225 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.From = nil
	} else {
		yyv1228 := &x.From
		yym1229 := z.DecBinary()
		_ = yym1229
		if false {
		} else {
			h.decSliceNetworkPolicyPeer((*[]NetworkPolicyPeer)(yyv1228), d)
		}
	}
	for {
		yyj1225++
		if yyhl1225 {
			yyb1225 = yyj1225 > l
		} else {
			yyb1225 = r.CheckBreak()
		}
		if yyb1225 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1225-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *NetworkPolicyPort) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym1230 := z.EncBinary()
		_ = yym1230
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1231 := !z.EncBinary()
			yy2arr1231 := z.EncBasicHandle().StructToArray
			var yyq1231 [2]bool
			_, _, _ = yysep1231, yyq1231, yy2arr1231
			const yyr1231 bool = false
			yyq1231[0] = x.Protocol != nil
			yyq1231[1] = x.Port != nil
			var yynn1231 int
			if yyr1231 || yy2arr1231 {
				r.EncodeArrayStart(2)
			} else {
				yynn1231 = 0
				for _, b := range yyq1231 {
					if b {
						yynn1231++
					}
				}
				r.EncodeMapStart(yynn1231)
				yynn1231 = 0
			}
			if yyr1231 || yy2arr1231 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1231[0] {
					if x.Protocol == nil {
						r.EncodeNil()
					} else {
						yy1233 := *x.Protocol
						yym1234 := z.EncBinary()
						_ = yym1234
						if false {
						} else if z.HasExtensions() && z.EncExt(yy1233) {
						} else {
							r.EncodeString(codecSelferC_UTF81234, string(yy1233))
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1231[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("protocol"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.Protocol == nil {
						r.EncodeNil()
					} else {
						yy1235 := *x.Protocol
						yym1236 := z.EncBinary()
						_ = yym1236
						if false {
						} else if z.HasExtensions() && z.EncExt(yy1235) {
						} else {
							r.EncodeString(codecSelferC_UTF81234, string(yy1235))
						}
					}
				}
			}
			if yyr1231 || yy2arr1231 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1231[1] {
					if x.Port == nil {
						r.EncodeNil()
					} else {
						yym1238 := z.EncBinary()
						_ = yym1238
						if false {
						} else if z.HasExtensions() && z.EncExt(x.Port) {
						} else if !yym1238 && z.IsJSONHandle() {
							z.EncJSONMarshal(x.Port)
						} else {
							z.EncFallback(x.Port)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1231[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("port"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.Port == nil {
						r.EncodeNil()
					} else {
						yym1239 := z.EncBinary()
						_ = yym1239
						if false {
						} else if z.HasExtensions() && z.EncExt(x.Port) {
						} else if !yym1239 && z.IsJSONHandle() {
							z.EncJSONMarshal(x.Port)
						} else {
							z.EncFallback(x.Port)
						}
					}
				}
			}
			if yyr1231 || yy2arr1231 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *NetworkPolicyPort) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym1240 := z.DecBinary()
	_ = yym1240
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1241 := r.ContainerType()
		if yyct1241 == codecSelferValueTypeMap1234 {
			yyl1241 := r.ReadMapStart()
			if yyl1241 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1241, d)
			}
		} else if yyct1241 == codecSelferValueTypeArray1234 {
			yyl1241 := r.ReadArrayStart()
			if yyl1241 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1241, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *NetworkPolicyPort) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys1242Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1242Slc
	var yyhl1242 bool = l >= 0
	for yyj1242 := 0; ; yyj1242++ {
		if yyhl1242 {
			if yyj1242 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1242Slc = r.DecodeBytes(yys1242Slc, true, true)
		yys1242 := string(yys1242Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1242 {
		case "protocol":
			if r.TryDecodeAsNil() {
				if x.Protocol != nil {
					x.Protocol = nil
				}
			} else {
				if x.Protocol == nil {
					x.Protocol = new(pkg2_api.Protocol)
				}
				x.Protocol.CodecDecodeSelf(d)
			}
		case "port":
			if r.TryDecodeAsNil() {
				if x.Port != nil {
					x.Port = nil
				}
			} else {
				if x.Port == nil {
					x.Port = new(pkg5_intstr.IntOrString)
				}
				yym1245 := z.DecBinary()
				_ = yym1245
				if false {
				} else if z.HasExtensions() && z.DecExt(x.Port) {
				} else if !yym1245 && z.IsJSONHandle() {
					z.DecJSONUnmarshal(x.Port)
				} else {
					z.DecFallback(x.Port, false)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys1242)
		} // end switch yys1242
	} // end for yyj1242
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *NetworkPolicyPort) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj1246 int
	var yyb1246 bool
	var yyhl1246 bool = l >= 0
	yyj1246++
	if yyhl1246 {
		yyb1246 = yyj1246 > l
	} else {
		yyb1246 = r.CheckBreak()
	}
	if yyb1246 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		if x.Protocol != nil {
			x.Protocol = nil
		}
	} else {
		if x.Protocol == nil {
			x.Protocol = new(pkg2_api.Protocol)
		}
		x.Protocol.CodecDecodeSelf(d)
	}
	yyj1246++
	if yyhl1246 {
		yyb1246 = yyj1246 > l
	} else {
		yyb1246 = r.CheckBreak()
	}
	if yyb1246 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		if x.Port != nil {
			x.Port = nil
		}
	} else {
		if x.Port == nil {
			x.Port = new(pkg5_intstr.IntOrString)
		}
		yym1249 := z.DecBinary()
		_ = yym1249
		if false {
		} else if z.HasExtensions() && z.DecExt(x.Port) {
		} else if !yym1249 && z.IsJSONHandle() {
			z.DecJSONUnmarshal(x.Port)
		} else {
			z.DecFallback(x.Port, false)
		}
	}
	for {
		yyj1246++
		if yyhl1246 {
			yyb1246 = yyj1246 > l
		} else {
			yyb1246 = r.CheckBreak()
		}
		if yyb1246 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1246-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *NetworkPolicyPeer) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym1250 := z.EncBinary()
		_ = yym1250
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1251 := !z.EncBinary()
			yy2arr1251 := z.EncBasicHandle().StructToArray
			var yyq1251 [2]bool
			_, _, _ = yysep1251, yyq1251, yy2arr1251
			const yyr1251 bool = false
			yyq1251[0] = x.PodSelector != nil
			yyq1251[1] = x.NamespaceSelector != nil
			var yynn1251 int
			if yyr1251 || yy2arr1251 {
				r.EncodeArrayStart(2)
			} else {
				yynn1251 = 0
				for _, b := range yyq1251 {
					if b {
						yynn1251++
					}
				}
				r.EncodeMapStart(yynn1251)
				yynn1251 = 0
			}
			if yyr1251 || yy2arr1251 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1251[0] {
					if x.PodSelector == nil {
						r.EncodeNil()
					} else {
						yym1253 := z.EncBinary()
						_ = yym1253
						if false {
						} else if z.HasExtensions() && z.EncExt(x.PodSelector) {
						} else {
							z.EncFallback(x.PodSelector)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1251[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("podSelector"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.PodSelector == nil {
						r.EncodeNil()
					} else {
						yym1254 := z.EncBinary()
						_ = yym1254
						if false {
						} else if z.HasExtensions() && z.EncExt(x.PodSelector) {
						} else {
							z.EncFallback(x.PodSelector)
						}
					}
				}
			}
			if yyr1251 || yy2arr1251 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1251[1] {
					if x.NamespaceSelector == nil {
						r.EncodeNil()
					} else {
						yym1256 := z.EncBinary()
						_ = yym1256
						if false {
						} else if z.HasExtensions() && z.EncExt(x.NamespaceSelector) {
						} else {
							z.EncFallback(x.NamespaceSelector)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1251[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("namespaceSelector"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.NamespaceSelector == nil {
						r.EncodeNil()
					} else {
						yym1257 := z.EncBinary()
						_ = yym1257
						if false {
						} else if z.HasExtensions() && z.EncExt(x.NamespaceSelector) {
						} else {
							z.EncFallback(x.NamespaceSelector)
						}
					}
				}
			}
			if yyr1251 || yy2arr1251 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *NetworkPolicyPeer) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym1258 := z.DecBinary()
	_ = yym1258
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1259 := r.ContainerType()
		if yyct1259 == codecSelferValueTypeMap1234 {
			yyl1259 := r.ReadMapStart()
			if yyl1259 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1259, d)
			}
		} else if yyct1259 == codecSelferValueTypeArray1234 {
			yyl1259 := r.ReadArrayStart()
			if yyl1259 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1259, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *NetworkPolicyPeer) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys1260Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1260Slc
	var yyhl1260 bool = l >= 0
	for yyj1260 := 0; ; yyj1260++ {
		if yyhl1260 {
			if yyj1260 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1260Slc = r.DecodeBytes(yys1260Slc, true, true)
		yys1260 := string(yys1260Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1260 {
		case "podSelector":
			if r.TryDecodeAsNil() {
				if x.PodSelector != nil {
					x.PodSelector = nil
				}
			} else {
				if x.PodSelector == nil {
					x.PodSelector = new(pkg1_unversioned.LabelSelector)
				}
				yym1262 := z.DecBinary()
				_ = yym1262
				if false {
				} else if z.HasExtensions() && z.DecExt(x.PodSelector) {
				} else {
					z.DecFallback(x.PodSelector, false)
				}
			}
		case "namespaceSelector":
			if r.TryDecodeAsNil() {
				if x.NamespaceSelector != nil {
					x.NamespaceSelector = nil
				}
			} else {
				if x.NamespaceSelector == nil {
					x.NamespaceSelector = new(pkg1_unversioned.LabelSelector)
				}
				yym1264 := z.DecBinary()
				_ = yym1264
				if false {
				} else if z.HasExtensions() && z.DecExt(x.NamespaceSelector) {
				} else {
					z.DecFallback(x.NamespaceSelector, false)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys1260)
		} // end switch yys1260
	} // end for yyj1260
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *NetworkPolicyPeer) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj1265 int
	var yyb1265 bool
	var yyhl1265 bool = l >= 0
	yyj1265++
	if yyhl1265 {
		yyb1265 = yyj1265 > l
	} else {
		yyb1265 = r.CheckBreak()
	}
	if yyb1265 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		if x.PodSelector != nil {
			x.PodSelector = nil
		}
	} else {
		if x.PodSelector == nil {
			x.PodSelector = new(pkg1_unversioned.LabelSelector)
		}
		yym1267 := z.DecBinary()
		_ = yym1267
		if false {
		} else if z.HasExtensions() && z.DecExt(x.PodSelector) {
		} else {
			z.DecFallback(x.PodSelector, false)
		}
	}
	yyj1265++
	if yyhl1265 {
		yyb1265 = yyj1265 > l
	} else {
		yyb1265 = r.CheckBreak()
	}
	if yyb1265 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		if x.NamespaceSelector != nil {
			x.NamespaceSelector = nil
		}
	} else {
		if x.NamespaceSelector == nil {
			x.NamespaceSelector = new(pkg1_unversioned.LabelSelector)
		}
		yym1269 := z.DecBinary()
		_ = yym1269
		if false {
		} else if z.HasExtensions() && z.DecExt(x.NamespaceSelector) {
		} else {
			z.DecFallback(x.NamespaceSelector, false)
		}
	}
	for {
		yyj1265++
		if yyhl1265 {
			yyb1265 = yyj1265 > l
		} else {
			yyb1265 = r.CheckBreak()
		}
		if yyb1265 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1265-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *NetworkPolicyList) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym1270 := z.EncBinary()
		_ = yym1270
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1271 := !z.EncBinary()
			yy2arr1271 := z.EncBasicHandle().StructToArray
			var yyq1271 [4]bool
			_, _, _ = yysep1271, yyq1271, yy2arr1271
			const yyr1271 bool = false
			yyq1271[0] = x.Kind != ""
			yyq1271[1] = x.APIVersion != ""
			yyq1271[2] = true
			var yynn1271 int
			if yyr1271 || yy2arr1271 {
				r.EncodeArrayStart(4)
			} else {
				yynn1271 = 1
				for _, b := range yyq1271 {
					if b {
						yynn1271++
					}
				}
				r.EncodeMapStart(yynn1271)
				yynn1271 = 0
			}
			if yyr1271 || yy2arr1271 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1271[0] {
					yym1273 := z.EncBinary()
					_ = yym1273
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1271[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1274 := z.EncBinary()
					_ = yym1274
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr1271 || yy2arr1271 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1271[1] {
					yym1276 := z.EncBinary()
					_ = yym1276
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1271[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1277 := z.EncBinary()
					_ = yym1277
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr1271 || yy2arr1271 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1271[2] {
					yy1279 := &x.ListMeta
					yym1280 := z.EncBinary()
					_ = yym1280
					if false {
					} else if z.HasExtensions() && z.EncExt(yy1279) {
					} else {
						z.EncFallback(yy1279)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1271[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy1281 := &x.ListMeta
					yym1282 := z.EncBinary()
					_ = yym1282
					if false {
					} else if z.HasExtensions() && z.EncExt(yy1281) {
					} else {
						z.EncFallback(yy1281)
					}
				}
			}
			if yyr1271 || yy2arr1271 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym1284 := z.EncBinary()
					_ = yym1284
					if false {
					} else {
						h.encSliceNetworkPolicy(([]NetworkPolicy)(x.Items), e)
					}
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("items"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym1285 := z.EncBinary()
					_ = yym1285
					if false {
					} else {
						h.encSliceNetworkPolicy(([]NetworkPolicy)(x.Items), e)
					}
				}
			}
			if yyr1271 || yy2arr1271 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *NetworkPolicyList) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym1286 := z.DecBinary()
	_ = yym1286
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1287 := r.ContainerType()
		if yyct1287 == codecSelferValueTypeMap1234 {
			yyl1287 := r.ReadMapStart()
			if yyl1287 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1287, d)
			}
		} else if yyct1287 == codecSelferValueTypeArray1234 {
			yyl1287 := r.ReadArrayStart()
			if yyl1287 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1287, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *NetworkPolicyList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys1288Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1288Slc
	var yyhl1288 bool = l >= 0
	for yyj1288 := 0; ; yyj1288++ {
		if yyhl1288 {
			if yyj1288 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1288Slc = r.DecodeBytes(yys1288Slc, true, true)
		yys1288 := string(yys1288Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1288 {
		case "kind":
			if r.TryDecodeAsNil() {
				x.Kind = ""
			} else {
				x.Kind = string(r.DecodeString())
			}
		case "apiVersion":
			if r.TryDecodeAsNil() {
				x.APIVersion = ""
			} else {
				x.APIVersion = string(r.DecodeString())
			}
		case "metadata":
			if r.TryDecodeAsNil() {
				x.ListMeta = pkg1_unversioned.ListMeta{}
			} else {
				yyv1291 := &x.ListMeta
				yym1292 := z.DecBinary()
				_ = yym1292
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv1291) {
				} else {
					z.DecFallback(yyv1291, false)
				}
			}
		case "items":
			if r.TryDecodeAsNil() {
				x.Items = nil
			} else {
				yyv1293 := &x.Items
				yym1294 := z.DecBinary()
				_ = yym1294
				if false {
				} else {
					h.decSliceNetworkPolicy((*[]NetworkPolicy)(yyv1293), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys1288)
		} // end switch yys1288
	} // end for yyj1288
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *NetworkPolicyList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj1295 int
	var yyb1295 bool
	var yyhl1295 bool = l >= 0
	yyj1295++
	if yyhl1295 {
		yyb1295 = yyj1295 > l
	} else {
		yyb1295 = r.CheckBreak()
	}
	if yyb1295 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj1295++
	if yyhl1295 {
		yyb1295 = yyj1295 > l
	} else {
		yyb1295 = r.CheckBreak()
	}
	if yyb1295 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj1295++
	if yyhl1295 {
		yyb1295 = yyj1295 > l
	} else {
		yyb1295 = r.CheckBreak()
	}
	if yyb1295 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ListMeta = pkg1_unversioned.ListMeta{}
	} else {
		yyv1298 := &x.ListMeta
		yym1299 := z.DecBinary()
		_ = yym1299
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv1298) {
		} else {
			z.DecFallback(yyv1298, false)
		}
	}
	yyj1295++
	if yyhl1295 {
		yyb1295 = yyj1295 > l
	} else {
		yyb1295 = r.CheckBreak()
	}
	if yyb1295 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Items = nil
	} else {
		yyv1300 := &x.Items
		yym1301 := z.DecBinary()
		_ = yym1301
		if false {
		} else {
			h.decSliceNetworkPolicy((*[]NetworkPolicy)(yyv1300), d)
		}
	}
	for {
		yyj1295++
		if yyhl1295 {
			yyb1295 = yyj1295 > l
		} else {
			yyb1295 = r.CheckBreak()
		}
		if yyb1295 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1295-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x codecSelfer1234) encSliceCustomMetricTarget(v []CustomMetricTarget, e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	r.EncodeArrayStart(len(v))
	for _, yyv1302 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem1234)
		yy1303 := &yyv1302
		yy1303.CodecEncodeSelf(e)
	}
	z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x codecSelfer1234) decSliceCustomMetricTarget(v *[]CustomMetricTarget, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r

	yyv1304 := *v
	yyh1304, yyl1304 := z.DecSliceHelperStart()
	var yyc1304 bool
	if yyl1304 == 0 {
		if yyv1304 == nil {
			yyv1304 = []CustomMetricTarget{}
			yyc1304 = true
		} else if len(yyv1304) != 0 {
			yyv1304 = yyv1304[:0]
			yyc1304 = true
		}
	} else if yyl1304 > 0 {
		var yyrr1304, yyrl1304 int
		var yyrt1304 bool
		if yyl1304 > cap(yyv1304) {

			yyrg1304 := len(yyv1304) > 0
			yyv21304 := yyv1304
			yyrl1304, yyrt1304 = z.DecInferLen(yyl1304, z.DecBasicHandle().MaxInitLen, 72)
			if yyrt1304 {
				if yyrl1304 <= cap(yyv1304) {
					yyv1304 = yyv1304[:yyrl1304]
				} else {
					yyv1304 = make([]CustomMetricTarget, yyrl1304)
				}
			} else {
				yyv1304 = make([]CustomMetricTarget, yyrl1304)
			}
			yyc1304 = true
			yyrr1304 = len(yyv1304)
			if yyrg1304 {
				copy(yyv1304, yyv21304)
			}
		} else if yyl1304 != len(yyv1304) {
			yyv1304 = yyv1304[:yyl1304]
			yyc1304 = true
		}
		yyj1304 := 0
		for ; yyj1304 < yyrr1304; yyj1304++ {
			yyh1304.ElemContainerState(yyj1304)
			if r.TryDecodeAsNil() {
				yyv1304[yyj1304] = CustomMetricTarget{}
			} else {
				yyv1305 := &yyv1304[yyj1304]
				yyv1305.CodecDecodeSelf(d)
			}

		}
		if yyrt1304 {
			for ; yyj1304 < yyl1304; yyj1304++ {
				yyv1304 = append(yyv1304, CustomMetricTarget{})
				yyh1304.ElemContainerState(yyj1304)
				if r.TryDecodeAsNil() {
					yyv1304[yyj1304] = CustomMetricTarget{}
				} else {
					yyv1306 := &yyv1304[yyj1304]
					yyv1306.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		yyj1304 := 0
		for ; !r.CheckBreak(); yyj1304++ {

			if yyj1304 >= len(yyv1304) {
				yyv1304 = append(yyv1304, CustomMetricTarget{}) // var yyz1304 CustomMetricTarget
				yyc1304 = true
			}
			yyh1304.ElemContainerState(yyj1304)
			if yyj1304 < len(yyv1304) {
				if r.TryDecodeAsNil() {
					yyv1304[yyj1304] = CustomMetricTarget{}
				} else {
					yyv1307 := &yyv1304[yyj1304]
					yyv1307.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1304 < len(yyv1304) {
			yyv1304 = yyv1304[:yyj1304]
			yyc1304 = true
		} else if yyj1304 == 0 && yyv1304 == nil {
			yyv1304 = []CustomMetricTarget{}
			yyc1304 = true
		}
	}
	yyh1304.End()
	if yyc1304 {
		*v = yyv1304
	}
}

func (x codecSelfer1234) encSliceCustomMetricCurrentStatus(v []CustomMetricCurrentStatus, e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	r.EncodeArrayStart(len(v))
	for _, yyv1308 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem1234)
		yy1309 := &yyv1308
		yy1309.CodecEncodeSelf(e)
	}
	z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x codecSelfer1234) decSliceCustomMetricCurrentStatus(v *[]CustomMetricCurrentStatus, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r

	yyv1310 := *v
	yyh1310, yyl1310 := z.DecSliceHelperStart()
	var yyc1310 bool
	if yyl1310 == 0 {
		if yyv1310 == nil {
			yyv1310 = []CustomMetricCurrentStatus{}
			yyc1310 = true
		} else if len(yyv1310) != 0 {
			yyv1310 = yyv1310[:0]
			yyc1310 = true
		}
	} else if yyl1310 > 0 {
		var yyrr1310, yyrl1310 int
		var yyrt1310 bool
		if yyl1310 > cap(yyv1310) {

			yyrg1310 := len(yyv1310) > 0
			yyv21310 := yyv1310
			yyrl1310, yyrt1310 = z.DecInferLen(yyl1310, z.DecBasicHandle().MaxInitLen, 72)
			if yyrt1310 {
				if yyrl1310 <= cap(yyv1310) {
					yyv1310 = yyv1310[:yyrl1310]
				} else {
					yyv1310 = make([]CustomMetricCurrentStatus, yyrl1310)
				}
			} else {
				yyv1310 = make([]CustomMetricCurrentStatus, yyrl1310)
			}
			yyc1310 = true
			yyrr1310 = len(yyv1310)
			if yyrg1310 {
				copy(yyv1310, yyv21310)
			}
		} else if yyl1310 != len(yyv1310) {
			yyv1310 = yyv1310[:yyl1310]
			yyc1310 = true
		}
		yyj1310 := 0
		for ; yyj1310 < yyrr1310; yyj1310++ {
			yyh1310.ElemContainerState(yyj1310)
			if r.TryDecodeAsNil() {
				yyv1310[yyj1310] = CustomMetricCurrentStatus{}
			} else {
				yyv1311 := &yyv1310[yyj1310]
				yyv1311.CodecDecodeSelf(d)
			}

		}
		if yyrt1310 {
			for ; yyj1310 < yyl1310; yyj1310++ {
				yyv1310 = append(yyv1310, CustomMetricCurrentStatus{})
				yyh1310.ElemContainerState(yyj1310)
				if r.TryDecodeAsNil() {
					yyv1310[yyj1310] = CustomMetricCurrentStatus{}
				} else {
					yyv1312 := &yyv1310[yyj1310]
					yyv1312.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		yyj1310 := 0
		for ; !r.CheckBreak(); yyj1310++ {

			if yyj1310 >= len(yyv1310) {
				yyv1310 = append(yyv1310, CustomMetricCurrentStatus{}) // var yyz1310 CustomMetricCurrentStatus
				yyc1310 = true
			}
			yyh1310.ElemContainerState(yyj1310)
			if yyj1310 < len(yyv1310) {
				if r.TryDecodeAsNil() {
					yyv1310[yyj1310] = CustomMetricCurrentStatus{}
				} else {
					yyv1313 := &yyv1310[yyj1310]
					yyv1313.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1310 < len(yyv1310) {
			yyv1310 = yyv1310[:yyj1310]
			yyc1310 = true
		} else if yyj1310 == 0 && yyv1310 == nil {
			yyv1310 = []CustomMetricCurrentStatus{}
			yyc1310 = true
		}
	}
	yyh1310.End()
	if yyc1310 {
		*v = yyv1310
	}
}

func (x codecSelfer1234) encSliceAPIVersion(v []APIVersion, e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	r.EncodeArrayStart(len(v))
	for _, yyv1314 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem1234)
		yy1315 := &yyv1314
		yy1315.CodecEncodeSelf(e)
	}
	z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x codecSelfer1234) decSliceAPIVersion(v *[]APIVersion, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r

	yyv1316 := *v
	yyh1316, yyl1316 := z.DecSliceHelperStart()
	var yyc1316 bool
	if yyl1316 == 0 {
		if yyv1316 == nil {
			yyv1316 = []APIVersion{}
			yyc1316 = true
		} else if len(yyv1316) != 0 {
			yyv1316 = yyv1316[:0]
			yyc1316 = true
		}
	} else if yyl1316 > 0 {
		var yyrr1316, yyrl1316 int
		var yyrt1316 bool
		if yyl1316 > cap(yyv1316) {

			yyrg1316 := len(yyv1316) > 0
			yyv21316 := yyv1316
			yyrl1316, yyrt1316 = z.DecInferLen(yyl1316, z.DecBasicHandle().MaxInitLen, 16)
			if yyrt1316 {
				if yyrl1316 <= cap(yyv1316) {
					yyv1316 = yyv1316[:yyrl1316]
				} else {
					yyv1316 = make([]APIVersion, yyrl1316)
				}
			} else {
				yyv1316 = make([]APIVersion, yyrl1316)
			}
			yyc1316 = true
			yyrr1316 = len(yyv1316)
			if yyrg1316 {
				copy(yyv1316, yyv21316)
			}
		} else if yyl1316 != len(yyv1316) {
			yyv1316 = yyv1316[:yyl1316]
			yyc1316 = true
		}
		yyj1316 := 0
		for ; yyj1316 < yyrr1316; yyj1316++ {
			yyh1316.ElemContainerState(yyj1316)
			if r.TryDecodeAsNil() {
				yyv1316[yyj1316] = APIVersion{}
			} else {
				yyv1317 := &yyv1316[yyj1316]
				yyv1317.CodecDecodeSelf(d)
			}

		}
		if yyrt1316 {
			for ; yyj1316 < yyl1316; yyj1316++ {
				yyv1316 = append(yyv1316, APIVersion{})
				yyh1316.ElemContainerState(yyj1316)
				if r.TryDecodeAsNil() {
					yyv1316[yyj1316] = APIVersion{}
				} else {
					yyv1318 := &yyv1316[yyj1316]
					yyv1318.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		yyj1316 := 0
		for ; !r.CheckBreak(); yyj1316++ {

			if yyj1316 >= len(yyv1316) {
				yyv1316 = append(yyv1316, APIVersion{}) // var yyz1316 APIVersion
				yyc1316 = true
			}
			yyh1316.ElemContainerState(yyj1316)
			if yyj1316 < len(yyv1316) {
				if r.TryDecodeAsNil() {
					yyv1316[yyj1316] = APIVersion{}
				} else {
					yyv1319 := &yyv1316[yyj1316]
					yyv1319.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1316 < len(yyv1316) {
			yyv1316 = yyv1316[:yyj1316]
			yyc1316 = true
		} else if yyj1316 == 0 && yyv1316 == nil {
			yyv1316 = []APIVersion{}
			yyc1316 = true
		}
	}
	yyh1316.End()
	if yyc1316 {
		*v = yyv1316
	}
}

func (x codecSelfer1234) encSliceThirdPartyResource(v []ThirdPartyResource, e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	r.EncodeArrayStart(len(v))
	for _, yyv1320 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem1234)
		yy1321 := &yyv1320
		yy1321.CodecEncodeSelf(e)
	}
	z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x codecSelfer1234) decSliceThirdPartyResource(v *[]ThirdPartyResource, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r

	yyv1322 := *v
	yyh1322, yyl1322 := z.DecSliceHelperStart()
	var yyc1322 bool
	if yyl1322 == 0 {
		if yyv1322 == nil {
			yyv1322 = []ThirdPartyResource{}
			yyc1322 = true
		} else if len(yyv1322) != 0 {
			yyv1322 = yyv1322[:0]
			yyc1322 = true
		}
	} else if yyl1322 > 0 {
		var yyrr1322, yyrl1322 int
		var yyrt1322 bool
		if yyl1322 > cap(yyv1322) {

			yyrg1322 := len(yyv1322) > 0
			yyv21322 := yyv1322
			yyrl1322, yyrt1322 = z.DecInferLen(yyl1322, z.DecBasicHandle().MaxInitLen, 296)
			if yyrt1322 {
				if yyrl1322 <= cap(yyv1322) {
					yyv1322 = yyv1322[:yyrl1322]
				} else {
					yyv1322 = make([]ThirdPartyResource, yyrl1322)
				}
			} else {
				yyv1322 = make([]ThirdPartyResource, yyrl1322)
			}
			yyc1322 = true
			yyrr1322 = len(yyv1322)
			if yyrg1322 {
				copy(yyv1322, yyv21322)
			}
		} else if yyl1322 != len(yyv1322) {
			yyv1322 = yyv1322[:yyl1322]
			yyc1322 = true
		}
		yyj1322 := 0
		for ; yyj1322 < yyrr1322; yyj1322++ {
			yyh1322.ElemContainerState(yyj1322)
			if r.TryDecodeAsNil() {
				yyv1322[yyj1322] = ThirdPartyResource{}
			} else {
				yyv1323 := &yyv1322[yyj1322]
				yyv1323.CodecDecodeSelf(d)
			}

		}
		if yyrt1322 {
			for ; yyj1322 < yyl1322; yyj1322++ {
				yyv1322 = append(yyv1322, ThirdPartyResource{})
				yyh1322.ElemContainerState(yyj1322)
				if r.TryDecodeAsNil() {
					yyv1322[yyj1322] = ThirdPartyResource{}
				} else {
					yyv1324 := &yyv1322[yyj1322]
					yyv1324.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		yyj1322 := 0
		for ; !r.CheckBreak(); yyj1322++ {

			if yyj1322 >= len(yyv1322) {
				yyv1322 = append(yyv1322, ThirdPartyResource{}) // var yyz1322 ThirdPartyResource
				yyc1322 = true
			}
			yyh1322.ElemContainerState(yyj1322)
			if yyj1322 < len(yyv1322) {
				if r.TryDecodeAsNil() {
					yyv1322[yyj1322] = ThirdPartyResource{}
				} else {
					yyv1325 := &yyv1322[yyj1322]
					yyv1325.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1322 < len(yyv1322) {
			yyv1322 = yyv1322[:yyj1322]
			yyc1322 = true
		} else if yyj1322 == 0 && yyv1322 == nil {
			yyv1322 = []ThirdPartyResource{}
			yyc1322 = true
		}
	}
	yyh1322.End()
	if yyc1322 {
		*v = yyv1322
	}
}

func (x codecSelfer1234) encSliceDeployment(v []Deployment, e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	r.EncodeArrayStart(len(v))
	for _, yyv1326 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem1234)
		yy1327 := &yyv1326
		yy1327.CodecEncodeSelf(e)
	}
	z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x codecSelfer1234) decSliceDeployment(v *[]Deployment, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r

	yyv1328 := *v
	yyh1328, yyl1328 := z.DecSliceHelperStart()
	var yyc1328 bool
	if yyl1328 == 0 {
		if yyv1328 == nil {
			yyv1328 = []Deployment{}
			yyc1328 = true
		} else if len(yyv1328) != 0 {
			yyv1328 = yyv1328[:0]
			yyc1328 = true
		}
	} else if yyl1328 > 0 {
		var yyrr1328, yyrl1328 int
		var yyrt1328 bool
		if yyl1328 > cap(yyv1328) {

			yyrg1328 := len(yyv1328) > 0
			yyv21328 := yyv1328
			yyrl1328, yyrt1328 = z.DecInferLen(yyl1328, z.DecBasicHandle().MaxInitLen, 800)
			if yyrt1328 {
				if yyrl1328 <= cap(yyv1328) {
					yyv1328 = yyv1328[:yyrl1328]
				} else {
					yyv1328 = make([]Deployment, yyrl1328)
				}
			} else {
				yyv1328 = make([]Deployment, yyrl1328)
			}
			yyc1328 = true
			yyrr1328 = len(yyv1328)
			if yyrg1328 {
				copy(yyv1328, yyv21328)
			}
		} else if yyl1328 != len(yyv1328) {
			yyv1328 = yyv1328[:yyl1328]
			yyc1328 = true
		}
		yyj1328 := 0
		for ; yyj1328 < yyrr1328; yyj1328++ {
			yyh1328.ElemContainerState(yyj1328)
			if r.TryDecodeAsNil() {
				yyv1328[yyj1328] = Deployment{}
			} else {
				yyv1329 := &yyv1328[yyj1328]
				yyv1329.CodecDecodeSelf(d)
			}

		}
		if yyrt1328 {
			for ; yyj1328 < yyl1328; yyj1328++ {
				yyv1328 = append(yyv1328, Deployment{})
				yyh1328.ElemContainerState(yyj1328)
				if r.TryDecodeAsNil() {
					yyv1328[yyj1328] = Deployment{}
				} else {
					yyv1330 := &yyv1328[yyj1328]
					yyv1330.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		yyj1328 := 0
		for ; !r.CheckBreak(); yyj1328++ {

			if yyj1328 >= len(yyv1328) {
				yyv1328 = append(yyv1328, Deployment{}) // var yyz1328 Deployment
				yyc1328 = true
			}
			yyh1328.ElemContainerState(yyj1328)
			if yyj1328 < len(yyv1328) {
				if r.TryDecodeAsNil() {
					yyv1328[yyj1328] = Deployment{}
				} else {
					yyv1331 := &yyv1328[yyj1328]
					yyv1331.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1328 < len(yyv1328) {
			yyv1328 = yyv1328[:yyj1328]
			yyc1328 = true
		} else if yyj1328 == 0 && yyv1328 == nil {
			yyv1328 = []Deployment{}
			yyc1328 = true
		}
	}
	yyh1328.End()
	if yyc1328 {
		*v = yyv1328
	}
}

func (x codecSelfer1234) encSliceDaemonSet(v []DaemonSet, e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	r.EncodeArrayStart(len(v))
	for _, yyv1332 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem1234)
		yy1333 := &yyv1332
		yy1333.CodecEncodeSelf(e)
	}
	z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x codecSelfer1234) decSliceDaemonSet(v *[]DaemonSet, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r

	yyv1334 := *v
	yyh1334, yyl1334 := z.DecSliceHelperStart()
	var yyc1334 bool
	if yyl1334 == 0 {
		if yyv1334 == nil {
			yyv1334 = []DaemonSet{}
			yyc1334 = true
		} else if len(yyv1334) != 0 {
			yyv1334 = yyv1334[:0]
			yyc1334 = true
		}
	} else if yyl1334 > 0 {
		var yyrr1334, yyrl1334 int
		var yyrt1334 bool
		if yyl1334 > cap(yyv1334) {

			yyrg1334 := len(yyv1334) > 0
			yyv21334 := yyv1334
			yyrl1334, yyrt1334 = z.DecInferLen(yyl1334, z.DecBasicHandle().MaxInitLen, 728)
			if yyrt1334 {
				if yyrl1334 <= cap(yyv1334) {
					yyv1334 = yyv1334[:yyrl1334]
				} else {
					yyv1334 = make([]DaemonSet, yyrl1334)
				}
			} else {
				yyv1334 = make([]DaemonSet, yyrl1334)
			}
			yyc1334 = true
			yyrr1334 = len(yyv1334)
			if yyrg1334 {
				copy(yyv1334, yyv21334)
			}
		} else if yyl1334 != len(yyv1334) {
			yyv1334 = yyv1334[:yyl1334]
			yyc1334 = true
		}
		yyj1334 := 0
		for ; yyj1334 < yyrr1334; yyj1334++ {
			yyh1334.ElemContainerState(yyj1334)
			if r.TryDecodeAsNil() {
				yyv1334[yyj1334] = DaemonSet{}
			} else {
				yyv1335 := &yyv1334[yyj1334]
				yyv1335.CodecDecodeSelf(d)
			}

		}
		if yyrt1334 {
			for ; yyj1334 < yyl1334; yyj1334++ {
				yyv1334 = append(yyv1334, DaemonSet{})
				yyh1334.ElemContainerState(yyj1334)
				if r.TryDecodeAsNil() {
					yyv1334[yyj1334] = DaemonSet{}
				} else {
					yyv1336 := &yyv1334[yyj1334]
					yyv1336.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		yyj1334 := 0
		for ; !r.CheckBreak(); yyj1334++ {

			if yyj1334 >= len(yyv1334) {
				yyv1334 = append(yyv1334, DaemonSet{}) // var yyz1334 DaemonSet
				yyc1334 = true
			}
			yyh1334.ElemContainerState(yyj1334)
			if yyj1334 < len(yyv1334) {
				if r.TryDecodeAsNil() {
					yyv1334[yyj1334] = DaemonSet{}
				} else {
					yyv1337 := &yyv1334[yyj1334]
					yyv1337.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1334 < len(yyv1334) {
			yyv1334 = yyv1334[:yyj1334]
			yyc1334 = true
		} else if yyj1334 == 0 && yyv1334 == nil {
			yyv1334 = []DaemonSet{}
			yyc1334 = true
		}
	}
	yyh1334.End()
	if yyc1334 {
		*v = yyv1334
	}
}

func (x codecSelfer1234) encSliceThirdPartyResourceData(v []ThirdPartyResourceData, e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	r.EncodeArrayStart(len(v))
	for _, yyv1338 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem1234)
		yy1339 := &yyv1338
		yy1339.CodecEncodeSelf(e)
	}
	z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x codecSelfer1234) decSliceThirdPartyResourceData(v *[]ThirdPartyResourceData, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r

	yyv1340 := *v
	yyh1340, yyl1340 := z.DecSliceHelperStart()
	var yyc1340 bool
	if yyl1340 == 0 {
		if yyv1340 == nil {
			yyv1340 = []ThirdPartyResourceData{}
			yyc1340 = true
		} else if len(yyv1340) != 0 {
			yyv1340 = yyv1340[:0]
			yyc1340 = true
		}
	} else if yyl1340 > 0 {
		var yyrr1340, yyrl1340 int
		var yyrt1340 bool
		if yyl1340 > cap(yyv1340) {

			yyrg1340 := len(yyv1340) > 0
			yyv21340 := yyv1340
			yyrl1340, yyrt1340 = z.DecInferLen(yyl1340, z.DecBasicHandle().MaxInitLen, 280)
			if yyrt1340 {
				if yyrl1340 <= cap(yyv1340) {
					yyv1340 = yyv1340[:yyrl1340]
				} else {
					yyv1340 = make([]ThirdPartyResourceData, yyrl1340)
				}
			} else {
				yyv1340 = make([]ThirdPartyResourceData, yyrl1340)
			}
			yyc1340 = true
			yyrr1340 = len(yyv1340)
			if yyrg1340 {
				copy(yyv1340, yyv21340)
			}
		} else if yyl1340 != len(yyv1340) {
			yyv1340 = yyv1340[:yyl1340]
			yyc1340 = true
		}
		yyj1340 := 0
		for ; yyj1340 < yyrr1340; yyj1340++ {
			yyh1340.ElemContainerState(yyj1340)
			if r.TryDecodeAsNil() {
				yyv1340[yyj1340] = ThirdPartyResourceData{}
			} else {
				yyv1341 := &yyv1340[yyj1340]
				yyv1341.CodecDecodeSelf(d)
			}

		}
		if yyrt1340 {
			for ; yyj1340 < yyl1340; yyj1340++ {
				yyv1340 = append(yyv1340, ThirdPartyResourceData{})
				yyh1340.ElemContainerState(yyj1340)
				if r.TryDecodeAsNil() {
					yyv1340[yyj1340] = ThirdPartyResourceData{}
				} else {
					yyv1342 := &yyv1340[yyj1340]
					yyv1342.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		yyj1340 := 0
		for ; !r.CheckBreak(); yyj1340++ {

			if yyj1340 >= len(yyv1340) {
				yyv1340 = append(yyv1340, ThirdPartyResourceData{}) // var yyz1340 ThirdPartyResourceData
				yyc1340 = true
			}
			yyh1340.ElemContainerState(yyj1340)
			if yyj1340 < len(yyv1340) {
				if r.TryDecodeAsNil() {
					yyv1340[yyj1340] = ThirdPartyResourceData{}
				} else {
					yyv1343 := &yyv1340[yyj1340]
					yyv1343.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1340 < len(yyv1340) {
			yyv1340 = yyv1340[:yyj1340]
			yyc1340 = true
		} else if yyj1340 == 0 && yyv1340 == nil {
			yyv1340 = []ThirdPartyResourceData{}
			yyc1340 = true
		}
	}
	yyh1340.End()
	if yyc1340 {
		*v = yyv1340
	}
}

func (x codecSelfer1234) encSliceIngress(v []Ingress, e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	r.EncodeArrayStart(len(v))
	for _, yyv1344 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem1234)
		yy1345 := &yyv1344
		yy1345.CodecEncodeSelf(e)
	}
	z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x codecSelfer1234) decSliceIngress(v *[]Ingress, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r

	yyv1346 := *v
	yyh1346, yyl1346 := z.DecSliceHelperStart()
	var yyc1346 bool
	if yyl1346 == 0 {
		if yyv1346 == nil {
			yyv1346 = []Ingress{}
			yyc1346 = true
		} else if len(yyv1346) != 0 {
			yyv1346 = yyv1346[:0]
			yyc1346 = true
		}
	} else if yyl1346 > 0 {
		var yyrr1346, yyrl1346 int
		var yyrt1346 bool
		if yyl1346 > cap(yyv1346) {

			yyrg1346 := len(yyv1346) > 0
			yyv21346 := yyv1346
			yyrl1346, yyrt1346 = z.DecInferLen(yyl1346, z.DecBasicHandle().MaxInitLen, 336)
			if yyrt1346 {
				if yyrl1346 <= cap(yyv1346) {
					yyv1346 = yyv1346[:yyrl1346]
				} else {
					yyv1346 = make([]Ingress, yyrl1346)
				}
			} else {
				yyv1346 = make([]Ingress, yyrl1346)
			}
			yyc1346 = true
			yyrr1346 = len(yyv1346)
			if yyrg1346 {
				copy(yyv1346, yyv21346)
			}
		} else if yyl1346 != len(yyv1346) {
			yyv1346 = yyv1346[:yyl1346]
			yyc1346 = true
		}
		yyj1346 := 0
		for ; yyj1346 < yyrr1346; yyj1346++ {
			yyh1346.ElemContainerState(yyj1346)
			if r.TryDecodeAsNil() {
				yyv1346[yyj1346] = Ingress{}
			} else {
				yyv1347 := &yyv1346[yyj1346]
				yyv1347.CodecDecodeSelf(d)
			}

		}
		if yyrt1346 {
			for ; yyj1346 < yyl1346; yyj1346++ {
				yyv1346 = append(yyv1346, Ingress{})
				yyh1346.ElemContainerState(yyj1346)
				if r.TryDecodeAsNil() {
					yyv1346[yyj1346] = Ingress{}
				} else {
					yyv1348 := &yyv1346[yyj1346]
					yyv1348.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		yyj1346 := 0
		for ; !r.CheckBreak(); yyj1346++ {

			if yyj1346 >= len(yyv1346) {
				yyv1346 = append(yyv1346, Ingress{}) // var yyz1346 Ingress
				yyc1346 = true
			}
			yyh1346.ElemContainerState(yyj1346)
			if yyj1346 < len(yyv1346) {
				if r.TryDecodeAsNil() {
					yyv1346[yyj1346] = Ingress{}
				} else {
					yyv1349 := &yyv1346[yyj1346]
					yyv1349.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1346 < len(yyv1346) {
			yyv1346 = yyv1346[:yyj1346]
			yyc1346 = true
		} else if yyj1346 == 0 && yyv1346 == nil {
			yyv1346 = []Ingress{}
			yyc1346 = true
		}
	}
	yyh1346.End()
	if yyc1346 {
		*v = yyv1346
	}
}

func (x codecSelfer1234) encSliceIngressTLS(v []IngressTLS, e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	r.EncodeArrayStart(len(v))
	for _, yyv1350 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem1234)
		yy1351 := &yyv1350
		yy1351.CodecEncodeSelf(e)
	}
	z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x codecSelfer1234) decSliceIngressTLS(v *[]IngressTLS, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r

	yyv1352 := *v
	yyh1352, yyl1352 := z.DecSliceHelperStart()
	var yyc1352 bool
	if yyl1352 == 0 {
		if yyv1352 == nil {
			yyv1352 = []IngressTLS{}
			yyc1352 = true
		} else if len(yyv1352) != 0 {
			yyv1352 = yyv1352[:0]
			yyc1352 = true
		}
	} else if yyl1352 > 0 {
		var yyrr1352, yyrl1352 int
		var yyrt1352 bool
		if yyl1352 > cap(yyv1352) {

			yyrg1352 := len(yyv1352) > 0
			yyv21352 := yyv1352
			yyrl1352, yyrt1352 = z.DecInferLen(yyl1352, z.DecBasicHandle().MaxInitLen, 40)
			if yyrt1352 {
				if yyrl1352 <= cap(yyv1352) {
					yyv1352 = yyv1352[:yyrl1352]
				} else {
					yyv1352 = make([]IngressTLS, yyrl1352)
				}
			} else {
				yyv1352 = make([]IngressTLS, yyrl1352)
			}
			yyc1352 = true
			yyrr1352 = len(yyv1352)
			if yyrg1352 {
				copy(yyv1352, yyv21352)
			}
		} else if yyl1352 != len(yyv1352) {
			yyv1352 = yyv1352[:yyl1352]
			yyc1352 = true
		}
		yyj1352 := 0
		for ; yyj1352 < yyrr1352; yyj1352++ {
			yyh1352.ElemContainerState(yyj1352)
			if r.TryDecodeAsNil() {
				yyv1352[yyj1352] = IngressTLS{}
			} else {
				yyv1353 := &yyv1352[yyj1352]
				yyv1353.CodecDecodeSelf(d)
			}

		}
		if yyrt1352 {
			for ; yyj1352 < yyl1352; yyj1352++ {
				yyv1352 = append(yyv1352, IngressTLS{})
				yyh1352.ElemContainerState(yyj1352)
				if r.TryDecodeAsNil() {
					yyv1352[yyj1352] = IngressTLS{}
				} else {
					yyv1354 := &yyv1352[yyj1352]
					yyv1354.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		yyj1352 := 0
		for ; !r.CheckBreak(); yyj1352++ {

			if yyj1352 >= len(yyv1352) {
				yyv1352 = append(yyv1352, IngressTLS{}) // var yyz1352 IngressTLS
				yyc1352 = true
			}
			yyh1352.ElemContainerState(yyj1352)
			if yyj1352 < len(yyv1352) {
				if r.TryDecodeAsNil() {
					yyv1352[yyj1352] = IngressTLS{}
				} else {
					yyv1355 := &yyv1352[yyj1352]
					yyv1355.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1352 < len(yyv1352) {
			yyv1352 = yyv1352[:yyj1352]
			yyc1352 = true
		} else if yyj1352 == 0 && yyv1352 == nil {
			yyv1352 = []IngressTLS{}
			yyc1352 = true
		}
	}
	yyh1352.End()
	if yyc1352 {
		*v = yyv1352
	}
}

func (x codecSelfer1234) encSliceIngressRule(v []IngressRule, e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	r.EncodeArrayStart(len(v))
	for _, yyv1356 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem1234)
		yy1357 := &yyv1356
		yy1357.CodecEncodeSelf(e)
	}
	z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x codecSelfer1234) decSliceIngressRule(v *[]IngressRule, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r

	yyv1358 := *v
	yyh1358, yyl1358 := z.DecSliceHelperStart()
	var yyc1358 bool
	if yyl1358 == 0 {
		if yyv1358 == nil {
			yyv1358 = []IngressRule{}
			yyc1358 = true
		} else if len(yyv1358) != 0 {
			yyv1358 = yyv1358[:0]
			yyc1358 = true
		}
	} else if yyl1358 > 0 {
		var yyrr1358, yyrl1358 int
		var yyrt1358 bool
		if yyl1358 > cap(yyv1358) {

			yyrg1358 := len(yyv1358) > 0
			yyv21358 := yyv1358
			yyrl1358, yyrt1358 = z.DecInferLen(yyl1358, z.DecBasicHandle().MaxInitLen, 24)
			if yyrt1358 {
				if yyrl1358 <= cap(yyv1358) {
					yyv1358 = yyv1358[:yyrl1358]
				} else {
					yyv1358 = make([]IngressRule, yyrl1358)
				}
			} else {
				yyv1358 = make([]IngressRule, yyrl1358)
			}
			yyc1358 = true
			yyrr1358 = len(yyv1358)
			if yyrg1358 {
				copy(yyv1358, yyv21358)
			}
		} else if yyl1358 != len(yyv1358) {
			yyv1358 = yyv1358[:yyl1358]
			yyc1358 = true
		}
		yyj1358 := 0
		for ; yyj1358 < yyrr1358; yyj1358++ {
			yyh1358.ElemContainerState(yyj1358)
			if r.TryDecodeAsNil() {
				yyv1358[yyj1358] = IngressRule{}
			} else {
				yyv1359 := &yyv1358[yyj1358]
				yyv1359.CodecDecodeSelf(d)
			}

		}
		if yyrt1358 {
			for ; yyj1358 < yyl1358; yyj1358++ {
				yyv1358 = append(yyv1358, IngressRule{})
				yyh1358.ElemContainerState(yyj1358)
				if r.TryDecodeAsNil() {
					yyv1358[yyj1358] = IngressRule{}
				} else {
					yyv1360 := &yyv1358[yyj1358]
					yyv1360.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		yyj1358 := 0
		for ; !r.CheckBreak(); yyj1358++ {

			if yyj1358 >= len(yyv1358) {
				yyv1358 = append(yyv1358, IngressRule{}) // var yyz1358 IngressRule
				yyc1358 = true
			}
			yyh1358.ElemContainerState(yyj1358)
			if yyj1358 < len(yyv1358) {
				if r.TryDecodeAsNil() {
					yyv1358[yyj1358] = IngressRule{}
				} else {
					yyv1361 := &yyv1358[yyj1358]
					yyv1361.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1358 < len(yyv1358) {
			yyv1358 = yyv1358[:yyj1358]
			yyc1358 = true
		} else if yyj1358 == 0 && yyv1358 == nil {
			yyv1358 = []IngressRule{}
			yyc1358 = true
		}
	}
	yyh1358.End()
	if yyc1358 {
		*v = yyv1358
	}
}

func (x codecSelfer1234) encSliceHTTPIngressPath(v []HTTPIngressPath, e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	r.EncodeArrayStart(len(v))
	for _, yyv1362 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem1234)
		yy1363 := &yyv1362
		yy1363.CodecEncodeSelf(e)
	}
	z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x codecSelfer1234) decSliceHTTPIngressPath(v *[]HTTPIngressPath, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r

	yyv1364 := *v
	yyh1364, yyl1364 := z.DecSliceHelperStart()
	var yyc1364 bool
	if yyl1364 == 0 {
		if yyv1364 == nil {
			yyv1364 = []HTTPIngressPath{}
			yyc1364 = true
		} else if len(yyv1364) != 0 {
			yyv1364 = yyv1364[:0]
			yyc1364 = true
		}
	} else if yyl1364 > 0 {
		var yyrr1364, yyrl1364 int
		var yyrt1364 bool
		if yyl1364 > cap(yyv1364) {

			yyrg1364 := len(yyv1364) > 0
			yyv21364 := yyv1364
			yyrl1364, yyrt1364 = z.DecInferLen(yyl1364, z.DecBasicHandle().MaxInitLen, 64)
			if yyrt1364 {
				if yyrl1364 <= cap(yyv1364) {
					yyv1364 = yyv1364[:yyrl1364]
				} else {
					yyv1364 = make([]HTTPIngressPath, yyrl1364)
				}
			} else {
				yyv1364 = make([]HTTPIngressPath, yyrl1364)
			}
			yyc1364 = true
			yyrr1364 = len(yyv1364)
			if yyrg1364 {
				copy(yyv1364, yyv21364)
			}
		} else if yyl1364 != len(yyv1364) {
			yyv1364 = yyv1364[:yyl1364]
			yyc1364 = true
		}
		yyj1364 := 0
		for ; yyj1364 < yyrr1364; yyj1364++ {
			yyh1364.ElemContainerState(yyj1364)
			if r.TryDecodeAsNil() {
				yyv1364[yyj1364] = HTTPIngressPath{}
			} else {
				yyv1365 := &yyv1364[yyj1364]
				yyv1365.CodecDecodeSelf(d)
			}

		}
		if yyrt1364 {
			for ; yyj1364 < yyl1364; yyj1364++ {
				yyv1364 = append(yyv1364, HTTPIngressPath{})
				yyh1364.ElemContainerState(yyj1364)
				if r.TryDecodeAsNil() {
					yyv1364[yyj1364] = HTTPIngressPath{}
				} else {
					yyv1366 := &yyv1364[yyj1364]
					yyv1366.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		yyj1364 := 0
		for ; !r.CheckBreak(); yyj1364++ {

			if yyj1364 >= len(yyv1364) {
				yyv1364 = append(yyv1364, HTTPIngressPath{}) // var yyz1364 HTTPIngressPath
				yyc1364 = true
			}
			yyh1364.ElemContainerState(yyj1364)
			if yyj1364 < len(yyv1364) {
				if r.TryDecodeAsNil() {
					yyv1364[yyj1364] = HTTPIngressPath{}
				} else {
					yyv1367 := &yyv1364[yyj1364]
					yyv1367.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1364 < len(yyv1364) {
			yyv1364 = yyv1364[:yyj1364]
			yyc1364 = true
		} else if yyj1364 == 0 && yyv1364 == nil {
			yyv1364 = []HTTPIngressPath{}
			yyc1364 = true
		}
	}
	yyh1364.End()
	if yyc1364 {
		*v = yyv1364
	}
}

func (x codecSelfer1234) encSliceReplicaSet(v []ReplicaSet, e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	r.EncodeArrayStart(len(v))
	for _, yyv1368 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem1234)
		yy1369 := &yyv1368
		yy1369.CodecEncodeSelf(e)
	}
	z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x codecSelfer1234) decSliceReplicaSet(v *[]ReplicaSet, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r

	yyv1370 := *v
	yyh1370, yyl1370 := z.DecSliceHelperStart()
	var yyc1370 bool
	if yyl1370 == 0 {
		if yyv1370 == nil {
			yyv1370 = []ReplicaSet{}
			yyc1370 = true
		} else if len(yyv1370) != 0 {
			yyv1370 = yyv1370[:0]
			yyc1370 = true
		}
	} else if yyl1370 > 0 {
		var yyrr1370, yyrl1370 int
		var yyrt1370 bool
		if yyl1370 > cap(yyv1370) {

			yyrg1370 := len(yyv1370) > 0
			yyv21370 := yyv1370
			yyrl1370, yyrt1370 = z.DecInferLen(yyl1370, z.DecBasicHandle().MaxInitLen, 744)
			if yyrt1370 {
				if yyrl1370 <= cap(yyv1370) {
					yyv1370 = yyv1370[:yyrl1370]
				} else {
					yyv1370 = make([]ReplicaSet, yyrl1370)
				}
			} else {
				yyv1370 = make([]ReplicaSet, yyrl1370)
			}
			yyc1370 = true
			yyrr1370 = len(yyv1370)
			if yyrg1370 {
				copy(yyv1370, yyv21370)
			}
		} else if yyl1370 != len(yyv1370) {
			yyv1370 = yyv1370[:yyl1370]
			yyc1370 = true
		}
		yyj1370 := 0
		for ; yyj1370 < yyrr1370; yyj1370++ {
			yyh1370.ElemContainerState(yyj1370)
			if r.TryDecodeAsNil() {
				yyv1370[yyj1370] = ReplicaSet{}
			} else {
				yyv1371 := &yyv1370[yyj1370]
				yyv1371.CodecDecodeSelf(d)
			}

		}
		if yyrt1370 {
			for ; yyj1370 < yyl1370; yyj1370++ {
				yyv1370 = append(yyv1370, ReplicaSet{})
				yyh1370.ElemContainerState(yyj1370)
				if r.TryDecodeAsNil() {
					yyv1370[yyj1370] = ReplicaSet{}
				} else {
					yyv1372 := &yyv1370[yyj1370]
					yyv1372.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		yyj1370 := 0
		for ; !r.CheckBreak(); yyj1370++ {

			if yyj1370 >= len(yyv1370) {
				yyv1370 = append(yyv1370, ReplicaSet{}) // var yyz1370 ReplicaSet
				yyc1370 = true
			}
			yyh1370.ElemContainerState(yyj1370)
			if yyj1370 < len(yyv1370) {
				if r.TryDecodeAsNil() {
					yyv1370[yyj1370] = ReplicaSet{}
				} else {
					yyv1373 := &yyv1370[yyj1370]
					yyv1373.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1370 < len(yyv1370) {
			yyv1370 = yyv1370[:yyj1370]
			yyc1370 = true
		} else if yyj1370 == 0 && yyv1370 == nil {
			yyv1370 = []ReplicaSet{}
			yyc1370 = true
		}
	}
	yyh1370.End()
	if yyc1370 {
		*v = yyv1370
	}
}

func (x codecSelfer1234) encSliceapi_Capability(v []pkg2_api.Capability, e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	r.EncodeArrayStart(len(v))
	for _, yyv1374 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem1234)
		yym1375 := z.EncBinary()
		_ = yym1375
		if false {
		} else if z.HasExtensions() && z.EncExt(yyv1374) {
		} else {
			r.EncodeString(codecSelferC_UTF81234, string(yyv1374))
		}
	}
	z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x codecSelfer1234) decSliceapi_Capability(v *[]pkg2_api.Capability, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r

	yyv1376 := *v
	yyh1376, yyl1376 := z.DecSliceHelperStart()
	var yyc1376 bool
	if yyl1376 == 0 {
		if yyv1376 == nil {
			yyv1376 = []pkg2_api.Capability{}
			yyc1376 = true
		} else if len(yyv1376) != 0 {
			yyv1376 = yyv1376[:0]
			yyc1376 = true
		}
	} else if yyl1376 > 0 {
		var yyrr1376, yyrl1376 int
		var yyrt1376 bool
		if yyl1376 > cap(yyv1376) {

			yyrl1376, yyrt1376 = z.DecInferLen(yyl1376, z.DecBasicHandle().MaxInitLen, 16)
			if yyrt1376 {
				if yyrl1376 <= cap(yyv1376) {
					yyv1376 = yyv1376[:yyrl1376]
				} else {
					yyv1376 = make([]pkg2_api.Capability, yyrl1376)
				}
			} else {
				yyv1376 = make([]pkg2_api.Capability, yyrl1376)
			}
			yyc1376 = true
			yyrr1376 = len(yyv1376)
		} else if yyl1376 != len(yyv1376) {
			yyv1376 = yyv1376[:yyl1376]
			yyc1376 = true
		}
		yyj1376 := 0
		for ; yyj1376 < yyrr1376; yyj1376++ {
			yyh1376.ElemContainerState(yyj1376)
			if r.TryDecodeAsNil() {
				yyv1376[yyj1376] = ""
			} else {
				yyv1376[yyj1376] = pkg2_api.Capability(r.DecodeString())
			}

		}
		if yyrt1376 {
			for ; yyj1376 < yyl1376; yyj1376++ {
				yyv1376 = append(yyv1376, "")
				yyh1376.ElemContainerState(yyj1376)
				if r.TryDecodeAsNil() {
					yyv1376[yyj1376] = ""
				} else {
					yyv1376[yyj1376] = pkg2_api.Capability(r.DecodeString())
				}

			}
		}

	} else {
		yyj1376 := 0
		for ; !r.CheckBreak(); yyj1376++ {

			if yyj1376 >= len(yyv1376) {
				yyv1376 = append(yyv1376, "") // var yyz1376 pkg2_api.Capability
				yyc1376 = true
			}
			yyh1376.ElemContainerState(yyj1376)
			if yyj1376 < len(yyv1376) {
				if r.TryDecodeAsNil() {
					yyv1376[yyj1376] = ""
				} else {
					yyv1376[yyj1376] = pkg2_api.Capability(r.DecodeString())
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1376 < len(yyv1376) {
			yyv1376 = yyv1376[:yyj1376]
			yyc1376 = true
		} else if yyj1376 == 0 && yyv1376 == nil {
			yyv1376 = []pkg2_api.Capability{}
			yyc1376 = true
		}
	}
	yyh1376.End()
	if yyc1376 {
		*v = yyv1376
	}
}

func (x codecSelfer1234) encSliceFSType(v []FSType, e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	r.EncodeArrayStart(len(v))
	for _, yyv1380 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem1234)
		yyv1380.CodecEncodeSelf(e)
	}
	z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x codecSelfer1234) decSliceFSType(v *[]FSType, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r

	yyv1381 := *v
	yyh1381, yyl1381 := z.DecSliceHelperStart()
	var yyc1381 bool
	if yyl1381 == 0 {
		if yyv1381 == nil {
			yyv1381 = []FSType{}
			yyc1381 = true
		} else if len(yyv1381) != 0 {
			yyv1381 = yyv1381[:0]
			yyc1381 = true
		}
	} else if yyl1381 > 0 {
		var yyrr1381, yyrl1381 int
		var yyrt1381 bool
		if yyl1381 > cap(yyv1381) {

			yyrl1381, yyrt1381 = z.DecInferLen(yyl1381, z.DecBasicHandle().MaxInitLen, 16)
			if yyrt1381 {
				if yyrl1381 <= cap(yyv1381) {
					yyv1381 = yyv1381[:yyrl1381]
				} else {
					yyv1381 = make([]FSType, yyrl1381)
				}
			} else {
				yyv1381 = make([]FSType, yyrl1381)
			}
			yyc1381 = true
			yyrr1381 = len(yyv1381)
		} else if yyl1381 != len(yyv1381) {
			yyv1381 = yyv1381[:yyl1381]
			yyc1381 = true
		}
		yyj1381 := 0
		for ; yyj1381 < yyrr1381; yyj1381++ {
			yyh1381.ElemContainerState(yyj1381)
			if r.TryDecodeAsNil() {
				yyv1381[yyj1381] = ""
			} else {
				yyv1381[yyj1381] = FSType(r.DecodeString())
			}

		}
		if yyrt1381 {
			for ; yyj1381 < yyl1381; yyj1381++ {
				yyv1381 = append(yyv1381, "")
				yyh1381.ElemContainerState(yyj1381)
				if r.TryDecodeAsNil() {
					yyv1381[yyj1381] = ""
				} else {
					yyv1381[yyj1381] = FSType(r.DecodeString())
				}

			}
		}

	} else {
		yyj1381 := 0
		for ; !r.CheckBreak(); yyj1381++ {

			if yyj1381 >= len(yyv1381) {
				yyv1381 = append(yyv1381, "") // var yyz1381 FSType
				yyc1381 = true
			}
			yyh1381.ElemContainerState(yyj1381)
			if yyj1381 < len(yyv1381) {
				if r.TryDecodeAsNil() {
					yyv1381[yyj1381] = ""
				} else {
					yyv1381[yyj1381] = FSType(r.DecodeString())
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1381 < len(yyv1381) {
			yyv1381 = yyv1381[:yyj1381]
			yyc1381 = true
		} else if yyj1381 == 0 && yyv1381 == nil {
			yyv1381 = []FSType{}
			yyc1381 = true
		}
	}
	yyh1381.End()
	if yyc1381 {
		*v = yyv1381
	}
}

func (x codecSelfer1234) encSliceHostPortRange(v []HostPortRange, e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	r.EncodeArrayStart(len(v))
	for _, yyv1385 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem1234)
		yy1386 := &yyv1385
		yy1386.CodecEncodeSelf(e)
	}
	z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x codecSelfer1234) decSliceHostPortRange(v *[]HostPortRange, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r

	yyv1387 := *v
	yyh1387, yyl1387 := z.DecSliceHelperStart()
	var yyc1387 bool
	if yyl1387 == 0 {
		if yyv1387 == nil {
			yyv1387 = []HostPortRange{}
			yyc1387 = true
		} else if len(yyv1387) != 0 {
			yyv1387 = yyv1387[:0]
			yyc1387 = true
		}
	} else if yyl1387 > 0 {
		var yyrr1387, yyrl1387 int
		var yyrt1387 bool
		if yyl1387 > cap(yyv1387) {

			yyrg1387 := len(yyv1387) > 0
			yyv21387 := yyv1387
			yyrl1387, yyrt1387 = z.DecInferLen(yyl1387, z.DecBasicHandle().MaxInitLen, 16)
			if yyrt1387 {
				if yyrl1387 <= cap(yyv1387) {
					yyv1387 = yyv1387[:yyrl1387]
				} else {
					yyv1387 = make([]HostPortRange, yyrl1387)
				}
			} else {
				yyv1387 = make([]HostPortRange, yyrl1387)
			}
			yyc1387 = true
			yyrr1387 = len(yyv1387)
			if yyrg1387 {
				copy(yyv1387, yyv21387)
			}
		} else if yyl1387 != len(yyv1387) {
			yyv1387 = yyv1387[:yyl1387]
			yyc1387 = true
		}
		yyj1387 := 0
		for ; yyj1387 < yyrr1387; yyj1387++ {
			yyh1387.ElemContainerState(yyj1387)
			if r.TryDecodeAsNil() {
				yyv1387[yyj1387] = HostPortRange{}
			} else {
				yyv1388 := &yyv1387[yyj1387]
				yyv1388.CodecDecodeSelf(d)
			}

		}
		if yyrt1387 {
			for ; yyj1387 < yyl1387; yyj1387++ {
				yyv1387 = append(yyv1387, HostPortRange{})
				yyh1387.ElemContainerState(yyj1387)
				if r.TryDecodeAsNil() {
					yyv1387[yyj1387] = HostPortRange{}
				} else {
					yyv1389 := &yyv1387[yyj1387]
					yyv1389.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		yyj1387 := 0
		for ; !r.CheckBreak(); yyj1387++ {

			if yyj1387 >= len(yyv1387) {
				yyv1387 = append(yyv1387, HostPortRange{}) // var yyz1387 HostPortRange
				yyc1387 = true
			}
			yyh1387.ElemContainerState(yyj1387)
			if yyj1387 < len(yyv1387) {
				if r.TryDecodeAsNil() {
					yyv1387[yyj1387] = HostPortRange{}
				} else {
					yyv1390 := &yyv1387[yyj1387]
					yyv1390.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1387 < len(yyv1387) {
			yyv1387 = yyv1387[:yyj1387]
			yyc1387 = true
		} else if yyj1387 == 0 && yyv1387 == nil {
			yyv1387 = []HostPortRange{}
			yyc1387 = true
		}
	}
	yyh1387.End()
	if yyc1387 {
		*v = yyv1387
	}
}

func (x codecSelfer1234) encSliceIDRange(v []IDRange, e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	r.EncodeArrayStart(len(v))
	for _, yyv1391 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem1234)
		yy1392 := &yyv1391
		yy1392.CodecEncodeSelf(e)
	}
	z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x codecSelfer1234) decSliceIDRange(v *[]IDRange, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r

	yyv1393 := *v
	yyh1393, yyl1393 := z.DecSliceHelperStart()
	var yyc1393 bool
	if yyl1393 == 0 {
		if yyv1393 == nil {
			yyv1393 = []IDRange{}
			yyc1393 = true
		} else if len(yyv1393) != 0 {
			yyv1393 = yyv1393[:0]
			yyc1393 = true
		}
	} else if yyl1393 > 0 {
		var yyrr1393, yyrl1393 int
		var yyrt1393 bool
		if yyl1393 > cap(yyv1393) {

			yyrg1393 := len(yyv1393) > 0
			yyv21393 := yyv1393
			yyrl1393, yyrt1393 = z.DecInferLen(yyl1393, z.DecBasicHandle().MaxInitLen, 16)
			if yyrt1393 {
				if yyrl1393 <= cap(yyv1393) {
					yyv1393 = yyv1393[:yyrl1393]
				} else {
					yyv1393 = make([]IDRange, yyrl1393)
				}
			} else {
				yyv1393 = make([]IDRange, yyrl1393)
			}
			yyc1393 = true
			yyrr1393 = len(yyv1393)
			if yyrg1393 {
				copy(yyv1393, yyv21393)
			}
		} else if yyl1393 != len(yyv1393) {
			yyv1393 = yyv1393[:yyl1393]
			yyc1393 = true
		}
		yyj1393 := 0
		for ; yyj1393 < yyrr1393; yyj1393++ {
			yyh1393.ElemContainerState(yyj1393)
			if r.TryDecodeAsNil() {
				yyv1393[yyj1393] = IDRange{}
			} else {
				yyv1394 := &yyv1393[yyj1393]
				yyv1394.CodecDecodeSelf(d)
			}

		}
		if yyrt1393 {
			for ; yyj1393 < yyl1393; yyj1393++ {
				yyv1393 = append(yyv1393, IDRange{})
				yyh1393.ElemContainerState(yyj1393)
				if r.TryDecodeAsNil() {
					yyv1393[yyj1393] = IDRange{}
				} else {
					yyv1395 := &yyv1393[yyj1393]
					yyv1395.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		yyj1393 := 0
		for ; !r.CheckBreak(); yyj1393++ {

			if yyj1393 >= len(yyv1393) {
				yyv1393 = append(yyv1393, IDRange{}) // var yyz1393 IDRange
				yyc1393 = true
			}
			yyh1393.ElemContainerState(yyj1393)
			if yyj1393 < len(yyv1393) {
				if r.TryDecodeAsNil() {
					yyv1393[yyj1393] = IDRange{}
				} else {
					yyv1396 := &yyv1393[yyj1393]
					yyv1396.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1393 < len(yyv1393) {
			yyv1393 = yyv1393[:yyj1393]
			yyc1393 = true
		} else if yyj1393 == 0 && yyv1393 == nil {
			yyv1393 = []IDRange{}
			yyc1393 = true
		}
	}
	yyh1393.End()
	if yyc1393 {
		*v = yyv1393
	}
}

func (x codecSelfer1234) encSlicePodSecurityPolicy(v []PodSecurityPolicy, e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	r.EncodeArrayStart(len(v))
	for _, yyv1397 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem1234)
		yy1398 := &yyv1397
		yy1398.CodecEncodeSelf(e)
	}
	z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x codecSelfer1234) decSlicePodSecurityPolicy(v *[]PodSecurityPolicy, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r

	yyv1399 := *v
	yyh1399, yyl1399 := z.DecSliceHelperStart()
	var yyc1399 bool
	if yyl1399 == 0 {
		if yyv1399 == nil {
			yyv1399 = []PodSecurityPolicy{}
			yyc1399 = true
		} else if len(yyv1399) != 0 {
			yyv1399 = yyv1399[:0]
			yyc1399 = true
		}
	} else if yyl1399 > 0 {
		var yyrr1399, yyrl1399 int
		var yyrt1399 bool
		if yyl1399 > cap(yyv1399) {

			yyrg1399 := len(yyv1399) > 0
			yyv21399 := yyv1399
			yyrl1399, yyrt1399 = z.DecInferLen(yyl1399, z.DecBasicHandle().MaxInitLen, 552)
			if yyrt1399 {
				if yyrl1399 <= cap(yyv1399) {
					yyv1399 = yyv1399[:yyrl1399]
				} else {
					yyv1399 = make([]PodSecurityPolicy, yyrl1399)
				}
			} else {
				yyv1399 = make([]PodSecurityPolicy, yyrl1399)
			}
			yyc1399 = true
			yyrr1399 = len(yyv1399)
			if yyrg1399 {
				copy(yyv1399, yyv21399)
			}
		} else if yyl1399 != len(yyv1399) {
			yyv1399 = yyv1399[:yyl1399]
			yyc1399 = true
		}
		yyj1399 := 0
		for ; yyj1399 < yyrr1399; yyj1399++ {
			yyh1399.ElemContainerState(yyj1399)
			if r.TryDecodeAsNil() {
				yyv1399[yyj1399] = PodSecurityPolicy{}
			} else {
				yyv1400 := &yyv1399[yyj1399]
				yyv1400.CodecDecodeSelf(d)
			}

		}
		if yyrt1399 {
			for ; yyj1399 < yyl1399; yyj1399++ {
				yyv1399 = append(yyv1399, PodSecurityPolicy{})
				yyh1399.ElemContainerState(yyj1399)
				if r.TryDecodeAsNil() {
					yyv1399[yyj1399] = PodSecurityPolicy{}
				} else {
					yyv1401 := &yyv1399[yyj1399]
					yyv1401.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		yyj1399 := 0
		for ; !r.CheckBreak(); yyj1399++ {

			if yyj1399 >= len(yyv1399) {
				yyv1399 = append(yyv1399, PodSecurityPolicy{}) // var yyz1399 PodSecurityPolicy
				yyc1399 = true
			}
			yyh1399.ElemContainerState(yyj1399)
			if yyj1399 < len(yyv1399) {
				if r.TryDecodeAsNil() {
					yyv1399[yyj1399] = PodSecurityPolicy{}
				} else {
					yyv1402 := &yyv1399[yyj1399]
					yyv1402.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1399 < len(yyv1399) {
			yyv1399 = yyv1399[:yyj1399]
			yyc1399 = true
		} else if yyj1399 == 0 && yyv1399 == nil {
			yyv1399 = []PodSecurityPolicy{}
			yyc1399 = true
		}
	}
	yyh1399.End()
	if yyc1399 {
		*v = yyv1399
	}
}

func (x codecSelfer1234) encSliceNetworkPolicyIngressRule(v []NetworkPolicyIngressRule, e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	r.EncodeArrayStart(len(v))
	for _, yyv1403 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem1234)
		yy1404 := &yyv1403
		yy1404.CodecEncodeSelf(e)
	}
	z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x codecSelfer1234) decSliceNetworkPolicyIngressRule(v *[]NetworkPolicyIngressRule, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r

	yyv1405 := *v
	yyh1405, yyl1405 := z.DecSliceHelperStart()
	var yyc1405 bool
	if yyl1405 == 0 {
		if yyv1405 == nil {
			yyv1405 = []NetworkPolicyIngressRule{}
			yyc1405 = true
		} else if len(yyv1405) != 0 {
			yyv1405 = yyv1405[:0]
			yyc1405 = true
		}
	} else if yyl1405 > 0 {
		var yyrr1405, yyrl1405 int
		var yyrt1405 bool
		if yyl1405 > cap(yyv1405) {

			yyrg1405 := len(yyv1405) > 0
			yyv21405 := yyv1405
			yyrl1405, yyrt1405 = z.DecInferLen(yyl1405, z.DecBasicHandle().MaxInitLen, 48)
			if yyrt1405 {
				if yyrl1405 <= cap(yyv1405) {
					yyv1405 = yyv1405[:yyrl1405]
				} else {
					yyv1405 = make([]NetworkPolicyIngressRule, yyrl1405)
				}
			} else {
				yyv1405 = make([]NetworkPolicyIngressRule, yyrl1405)
			}
			yyc1405 = true
			yyrr1405 = len(yyv1405)
			if yyrg1405 {
				copy(yyv1405, yyv21405)
			}
		} else if yyl1405 != len(yyv1405) {
			yyv1405 = yyv1405[:yyl1405]
			yyc1405 = true
		}
		yyj1405 := 0
		for ; yyj1405 < yyrr1405; yyj1405++ {
			yyh1405.ElemContainerState(yyj1405)
			if r.TryDecodeAsNil() {
				yyv1405[yyj1405] = NetworkPolicyIngressRule{}
			} else {
				yyv1406 := &yyv1405[yyj1405]
				yyv1406.CodecDecodeSelf(d)
			}

		}
		if yyrt1405 {
			for ; yyj1405 < yyl1405; yyj1405++ {
				yyv1405 = append(yyv1405, NetworkPolicyIngressRule{})
				yyh1405.ElemContainerState(yyj1405)
				if r.TryDecodeAsNil() {
					yyv1405[yyj1405] = NetworkPolicyIngressRule{}
				} else {
					yyv1407 := &yyv1405[yyj1405]
					yyv1407.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		yyj1405 := 0
		for ; !r.CheckBreak(); yyj1405++ {

			if yyj1405 >= len(yyv1405) {
				yyv1405 = append(yyv1405, NetworkPolicyIngressRule{}) // var yyz1405 NetworkPolicyIngressRule
				yyc1405 = true
			}
			yyh1405.ElemContainerState(yyj1405)
			if yyj1405 < len(yyv1405) {
				if r.TryDecodeAsNil() {
					yyv1405[yyj1405] = NetworkPolicyIngressRule{}
				} else {
					yyv1408 := &yyv1405[yyj1405]
					yyv1408.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1405 < len(yyv1405) {
			yyv1405 = yyv1405[:yyj1405]
			yyc1405 = true
		} else if yyj1405 == 0 && yyv1405 == nil {
			yyv1405 = []NetworkPolicyIngressRule{}
			yyc1405 = true
		}
	}
	yyh1405.End()
	if yyc1405 {
		*v = yyv1405
	}
}

func (x codecSelfer1234) encSliceNetworkPolicyPort(v []NetworkPolicyPort, e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	r.EncodeArrayStart(len(v))
	for _, yyv1409 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem1234)
		yy1410 := &yyv1409
		yy1410.CodecEncodeSelf(e)
	}
	z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x codecSelfer1234) decSliceNetworkPolicyPort(v *[]NetworkPolicyPort, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r

	yyv1411 := *v
	yyh1411, yyl1411 := z.DecSliceHelperStart()
	var yyc1411 bool
	if yyl1411 == 0 {
		if yyv1411 == nil {
			yyv1411 = []NetworkPolicyPort{}
			yyc1411 = true
		} else if len(yyv1411) != 0 {
			yyv1411 = yyv1411[:0]
			yyc1411 = true
		}
	} else if yyl1411 > 0 {
		var yyrr1411, yyrl1411 int
		var yyrt1411 bool
		if yyl1411 > cap(yyv1411) {

			yyrg1411 := len(yyv1411) > 0
			yyv21411 := yyv1411
			yyrl1411, yyrt1411 = z.DecInferLen(yyl1411, z.DecBasicHandle().MaxInitLen, 16)
			if yyrt1411 {
				if yyrl1411 <= cap(yyv1411) {
					yyv1411 = yyv1411[:yyrl1411]
				} else {
					yyv1411 = make([]NetworkPolicyPort, yyrl1411)
				}
			} else {
				yyv1411 = make([]NetworkPolicyPort, yyrl1411)
			}
			yyc1411 = true
			yyrr1411 = len(yyv1411)
			if yyrg1411 {
				copy(yyv1411, yyv21411)
			}
		} else if yyl1411 != len(yyv1411) {
			yyv1411 = yyv1411[:yyl1411]
			yyc1411 = true
		}
		yyj1411 := 0
		for ; yyj1411 < yyrr1411; yyj1411++ {
			yyh1411.ElemContainerState(yyj1411)
			if r.TryDecodeAsNil() {
				yyv1411[yyj1411] = NetworkPolicyPort{}
			} else {
				yyv1412 := &yyv1411[yyj1411]
				yyv1412.CodecDecodeSelf(d)
			}

		}
		if yyrt1411 {
			for ; yyj1411 < yyl1411; yyj1411++ {
				yyv1411 = append(yyv1411, NetworkPolicyPort{})
				yyh1411.ElemContainerState(yyj1411)
				if r.TryDecodeAsNil() {
					yyv1411[yyj1411] = NetworkPolicyPort{}
				} else {
					yyv1413 := &yyv1411[yyj1411]
					yyv1413.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		yyj1411 := 0
		for ; !r.CheckBreak(); yyj1411++ {

			if yyj1411 >= len(yyv1411) {
				yyv1411 = append(yyv1411, NetworkPolicyPort{}) // var yyz1411 NetworkPolicyPort
				yyc1411 = true
			}
			yyh1411.ElemContainerState(yyj1411)
			if yyj1411 < len(yyv1411) {
				if r.TryDecodeAsNil() {
					yyv1411[yyj1411] = NetworkPolicyPort{}
				} else {
					yyv1414 := &yyv1411[yyj1411]
					yyv1414.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1411 < len(yyv1411) {
			yyv1411 = yyv1411[:yyj1411]
			yyc1411 = true
		} else if yyj1411 == 0 && yyv1411 == nil {
			yyv1411 = []NetworkPolicyPort{}
			yyc1411 = true
		}
	}
	yyh1411.End()
	if yyc1411 {
		*v = yyv1411
	}
}

func (x codecSelfer1234) encSliceNetworkPolicyPeer(v []NetworkPolicyPeer, e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	r.EncodeArrayStart(len(v))
	for _, yyv1415 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem1234)
		yy1416 := &yyv1415
		yy1416.CodecEncodeSelf(e)
	}
	z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x codecSelfer1234) decSliceNetworkPolicyPeer(v *[]NetworkPolicyPeer, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r

	yyv1417 := *v
	yyh1417, yyl1417 := z.DecSliceHelperStart()
	var yyc1417 bool
	if yyl1417 == 0 {
		if yyv1417 == nil {
			yyv1417 = []NetworkPolicyPeer{}
			yyc1417 = true
		} else if len(yyv1417) != 0 {
			yyv1417 = yyv1417[:0]
			yyc1417 = true
		}
	} else if yyl1417 > 0 {
		var yyrr1417, yyrl1417 int
		var yyrt1417 bool
		if yyl1417 > cap(yyv1417) {

			yyrg1417 := len(yyv1417) > 0
			yyv21417 := yyv1417
			yyrl1417, yyrt1417 = z.DecInferLen(yyl1417, z.DecBasicHandle().MaxInitLen, 16)
			if yyrt1417 {
				if yyrl1417 <= cap(yyv1417) {
					yyv1417 = yyv1417[:yyrl1417]
				} else {
					yyv1417 = make([]NetworkPolicyPeer, yyrl1417)
				}
			} else {
				yyv1417 = make([]NetworkPolicyPeer, yyrl1417)
			}
			yyc1417 = true
			yyrr1417 = len(yyv1417)
			if yyrg1417 {
				copy(yyv1417, yyv21417)
			}
		} else if yyl1417 != len(yyv1417) {
			yyv1417 = yyv1417[:yyl1417]
			yyc1417 = true
		}
		yyj1417 := 0
		for ; yyj1417 < yyrr1417; yyj1417++ {
			yyh1417.ElemContainerState(yyj1417)
			if r.TryDecodeAsNil() {
				yyv1417[yyj1417] = NetworkPolicyPeer{}
			} else {
				yyv1418 := &yyv1417[yyj1417]
				yyv1418.CodecDecodeSelf(d)
			}

		}
		if yyrt1417 {
			for ; yyj1417 < yyl1417; yyj1417++ {
				yyv1417 = append(yyv1417, NetworkPolicyPeer{})
				yyh1417.ElemContainerState(yyj1417)
				if r.TryDecodeAsNil() {
					yyv1417[yyj1417] = NetworkPolicyPeer{}
				} else {
					yyv1419 := &yyv1417[yyj1417]
					yyv1419.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		yyj1417 := 0
		for ; !r.CheckBreak(); yyj1417++ {

			if yyj1417 >= len(yyv1417) {
				yyv1417 = append(yyv1417, NetworkPolicyPeer{}) // var yyz1417 NetworkPolicyPeer
				yyc1417 = true
			}
			yyh1417.ElemContainerState(yyj1417)
			if yyj1417 < len(yyv1417) {
				if r.TryDecodeAsNil() {
					yyv1417[yyj1417] = NetworkPolicyPeer{}
				} else {
					yyv1420 := &yyv1417[yyj1417]
					yyv1420.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1417 < len(yyv1417) {
			yyv1417 = yyv1417[:yyj1417]
			yyc1417 = true
		} else if yyj1417 == 0 && yyv1417 == nil {
			yyv1417 = []NetworkPolicyPeer{}
			yyc1417 = true
		}
	}
	yyh1417.End()
	if yyc1417 {
		*v = yyv1417
	}
}

func (x codecSelfer1234) encSliceNetworkPolicy(v []NetworkPolicy, e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	r.EncodeArrayStart(len(v))
	for _, yyv1421 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem1234)
		yy1422 := &yyv1421
		yy1422.CodecEncodeSelf(e)
	}
	z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x codecSelfer1234) decSliceNetworkPolicy(v *[]NetworkPolicy, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r

	yyv1423 := *v
	yyh1423, yyl1423 := z.DecSliceHelperStart()
	var yyc1423 bool
	if yyl1423 == 0 {
		if yyv1423 == nil {
			yyv1423 = []NetworkPolicy{}
			yyc1423 = true
		} else if len(yyv1423) != 0 {
			yyv1423 = yyv1423[:0]
			yyc1423 = true
		}
	} else if yyl1423 > 0 {
		var yyrr1423, yyrl1423 int
		var yyrt1423 bool
		if yyl1423 > cap(yyv1423) {

			yyrg1423 := len(yyv1423) > 0
			yyv21423 := yyv1423
			yyrl1423, yyrt1423 = z.DecInferLen(yyl1423, z.DecBasicHandle().MaxInitLen, 312)
			if yyrt1423 {
				if yyrl1423 <= cap(yyv1423) {
					yyv1423 = yyv1423[:yyrl1423]
				} else {
					yyv1423 = make([]NetworkPolicy, yyrl1423)
				}
			} else {
				yyv1423 = make([]NetworkPolicy, yyrl1423)
			}
			yyc1423 = true
			yyrr1423 = len(yyv1423)
			if yyrg1423 {
				copy(yyv1423, yyv21423)
			}
		} else if yyl1423 != len(yyv1423) {
			yyv1423 = yyv1423[:yyl1423]
			yyc1423 = true
		}
		yyj1423 := 0
		for ; yyj1423 < yyrr1423; yyj1423++ {
			yyh1423.ElemContainerState(yyj1423)
			if r.TryDecodeAsNil() {
				yyv1423[yyj1423] = NetworkPolicy{}
			} else {
				yyv1424 := &yyv1423[yyj1423]
				yyv1424.CodecDecodeSelf(d)
			}

		}
		if yyrt1423 {
			for ; yyj1423 < yyl1423; yyj1423++ {
				yyv1423 = append(yyv1423, NetworkPolicy{})
				yyh1423.ElemContainerState(yyj1423)
				if r.TryDecodeAsNil() {
					yyv1423[yyj1423] = NetworkPolicy{}
				} else {
					yyv1425 := &yyv1423[yyj1423]
					yyv1425.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		yyj1423 := 0
		for ; !r.CheckBreak(); yyj1423++ {

			if yyj1423 >= len(yyv1423) {
				yyv1423 = append(yyv1423, NetworkPolicy{}) // var yyz1423 NetworkPolicy
				yyc1423 = true
			}
			yyh1423.ElemContainerState(yyj1423)
			if yyj1423 < len(yyv1423) {
				if r.TryDecodeAsNil() {
					yyv1423[yyj1423] = NetworkPolicy{}
				} else {
					yyv1426 := &yyv1423[yyj1423]
					yyv1426.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1423 < len(yyv1423) {
			yyv1423 = yyv1423[:yyj1423]
			yyc1423 = true
		} else if yyj1423 == 0 && yyv1423 == nil {
			yyv1423 = []NetworkPolicy{}
			yyc1423 = true
		}
	}
	yyh1423.End()
	if yyc1423 {
		*v = yyv1423
	}
}
